¿Múltiples cuentas github en la misma computadora?


419

Intento trabajar en mis repositorios reales de "trabajo" y en mis repositorios personales en git hub desde mi computadora.

La cuenta de trabajo se configuró primero y todo funciona a la perfección.

Sin embargo, mi cuenta personal no parece empujar a mi repositorio personal, que está configurado bajo una cuenta / correo electrónico diferente.

Intenté copiar mi clave de trabajo en mi cuenta personal, pero eso arroja un error, porque, por supuesto, una clave solo se puede adjuntar a una cuenta.

¿Cómo puedo empujar / tirar hacia y desde ambas cuentas, desde sus respectivas credenciales de github?


3
Los pasos dados en el enlace http://net.tutsplus.com/tutorials/tools-and-tips/how-to-work-with-github-and-multiple-accounts funcionaron bien para mí y solo para agregar una cosa tienes que agregar tu clave de repositorio personal también usando <br> & nbsp; ssh-add ~/.ssh/id_rsa_COMPANY <br/> para decirle al agente ssh que lo incluya para su uso. <hr /> Rest funciona bien para mí con el tutorial mencionado anteriormente.
Brut3e

2
"porque, por supuesto, una clave solo se puede adjuntar a una cuenta" ¿por supuesto? ¿por qué?
Sparr

Git 2.13 en adelante admite las condiciones condicionales incluidas en .gitconfig, que son una forma útil de administrar identidades por jerarquía de carpetas. stackoverflow.com/a/36296990/901597
Joe Bowbeer

Respuestas:


275

Todo lo que necesita hacer es configurar su configuración SSH con múltiples pares de claves SSH.

Además, si está trabajando con múltiples repositorios utilizando diferentes personas, debe asegurarse de que sus repositorios individuales tengan la configuración del usuario anulada en consecuencia:

Configuración de nombre de usuario, correo electrónico y token GitHub: anulación de la configuración para repositorios individuales https://help.github.com/articles/setting-your-commit-email-address-in-git/

Espero que esto ayude.

Nota: Algunos de ustedes pueden requerir que se utilicen diferentes correos electrónicos para diferentes repositorios, desde git 2.13 puede configurar el correo electrónico en un directorio editando el archivo de configuración global que se encuentra en: ~/.gitconfigusando condicionales de esta manera:

[user]
    name = Pavan Kataria
    email = defaultemail@gmail.com

[includeIf "gitdir:~/work/"]
    path = ~/work/.gitconfig

Y luego su configuración específica de trabajo ~ / work / .gitconfig se vería así:

[user]
    email = pavan.kataria@company.tld

Gracias @alexg por informarme de esto en los comentarios.


44
El tercer enlace ahora está roto (varias claves SSH)
RustyTheBoyRobot

12
ese primer enlace ahora redirige a una página en las cuentas de usuario frente a las de la organización (no estoy seguro de si eso era lo que se pretendía originalmente). Este tutorial fue fácil de seguir y resolvió mis problemas.
Eric H.

1
@Camilo Porque no sé cuál es el nuevo enlace actualizado, así que si él está al tanto del enlace actualizado, entonces sería amable para él conectarlo :)
Pavan

44
@AlmasAdilbek Han pasado casi 3 años, los enlaces seguramente se romperán y continuarán rompiéndose. ¿Le importaría encontrar un artículo alternativo o encontrar la fuente original nuevamente para poder actualizar el enlace para mi amigo? No puedo seguir siempre arreglando enlaces rotos.
Pavan

3
Esta no es una respuesta sin resumir los pasos críticos en su publicación real. Esta respuesta ya ha sufrido la rotura del enlace una vez, pero no ha realizado la actualización necesaria para proporcionar una respuesta real a la pregunta.
Gracias

139

Use HTTPS:

cambie la URL remota a https:

git remote set-url origin https://USERNAME@github.com/USERNAME/PROJECTNAME.git

y eres bueno para ir:

git push

Para garantizar que las confirmaciones aparezcan tal como las realiza USERNAME, también se pueden configurar user.name y user.email para este proyecto:

git config user.name USERNAME
git config user.email USERNAME@example.com

8
La solución más simple para la descarga rápida desde otro repositorio privado.
Jaap Geurts

1
esta es la mejor solución que encontré sobre las pilas
Harvinder Singh

Esta solución proporciona el método más simple, ya que no quería agregar más claves ssh. Solo una nota, si ya configuró su user.namey user.emailcon la --globalbandera, simplemente haga lo que dice arriba para configurarlo localmente para ese único repositorio. Eso resolvió muchos problemas. Ahora para eliminar el antiguo repositorio ...
thatrobotguy

72

Ponerse en forma

Para administrar un repositorio git en una cuenta github / bitbucket / lo que sea, simplemente necesita generar una nueva clave SSH.

Pero antes de que podamos comenzar a empujar / tirar repositorios con su segunda identidad, debemos ponerlo en forma: supongamos que su sistema está configurado con un par típico id_rsay id_rsa.pubclave. Ahora tu tree ~/.sshaspecto es así

$ tree ~/.ssh
/Users/you/.ssh
├── known_hosts
├── id_rsa
└── id_rsa.pub

Primero, nombre ese par de claves: agregar un nombre descriptivo lo ayudará a recordar qué clave se utiliza para qué usuario / control remoto

# change to your ~/.ssh directory
$ cd ~/.ssh

# rename the private key
$ mv id_rsa github-mainuser

# rename the public key
$ mv id_rsa.pub github-mainuser.pub

A continuación, generemos un nuevo par de claves : aquí nombraré la nueva clavegithub-otheruser

$ ssh-keygen -t rsa -b 4096 -f ~/.ssh/github-otheruser

Ahora, cuando miramos tree ~/.sshvemos

$ tree ~/.ssh
/Users/you/.ssh
├── known_hosts
├── github-mainuser
├── github-mainuser.pub
├── github-otheruser
└── github-otheruser.pub

A continuación, necesitamos configurar un ~/.ssh/configarchivo que definirá nuestras configuraciones clave. Lo crearemos con los permisos adecuados de solo lectura / escritura del propietario

$ (umask 077; touch ~/.ssh/config)

Ábrelo con tu editor favorito y agrega los siguientes contenidos

Host github.com
  User git
  IdentityFile ~/.ssh/github-mainuser

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

Presumiblemente, tendrá algunos repositorios existentes asociados con su identidad primaria de Github. Por esa razón, el "predeterminado" github.com Hostestá configurado para usar su mainuserclave. Si no desea favorecer una cuenta sobre otra, le mostraré cómo actualizar repositorios existentes en su sistema para usar una configuración ssh actualizada.


Agregue su nueva clave SSH a github

Dirígete a github.com/settings/keys para agregar tu nueva clave pública

Puede obtener los contenidos de la clave pública usando: copiar / pegar en github

$ cat ~/.ssh/github-otheruser.pub
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDBVvWNQ2nO5...

Ahora su nueva identidad de usuario está configurada; a continuación le mostraremos cómo usarla.


Hacer cosas: clonar un repositorio

Entonces, ¿cómo se combina esto para trabajar con git y github? Bueno, porque no puedes tener un pollo sin huevo, veremos la clonación de un repositorio existente. Esta situación podría aplicarse a usted si tiene una nueva cuenta de github para su lugar de trabajo y fue agregado a un proyecto de la empresa.

Digamos que github.com/someorg/somerepoya existe y se le agregó: la clonación es tan fácil como

$ git clone github.com-otheruser:someorg/somerepo.git

Esa parte en negrita debe coincidir con el Hostnombre que configuramos en su ~/.ssh/configarchivo. Eso conecta correctamente git al correspondiente IdentityFiley lo autentica adecuadamente con github


Hacer las cosas: crear un nuevo repositorio

Bueno, debido a que no puedes tener un pollo y un huevo sin huevo, buscaremos publicar un nuevo repositorio en tu cuenta secundaria. Esta situación se aplica a los usuarios que crean nuevos contenido utilizando su cuenta secundaria de github.

Supongamos que ya ha hecho un poco de trabajo localmente y ahora está listo para empujar a Github. Puedes seguirme si quieres

$ cd ~
$ mkdir somerepo
$ cd somerepo
$ git init

Ahora configure este repositorio para usar su identidad

$ git config user.name "Mister Manager"
$ git config user.email "someuser@some.org"

Ahora haz tu primer commit

$ echo "hello world" > readme
$ git add .
$ git commit -m "first commit"

Verifique la confirmación para ver que su nueva identidad se usó usando git log

$ git log --pretty="%H %an <%ae>"
f397a7cfbf55d44ffdf87aa24974f0a5001e1921 Mister Manager <someuser@some.org>

Muy bien, es hora de empujar a github! Dado que github aún no conoce nuestro nuevo repositorio, primero vaya a github.com/new y cree su nuevo repositorio - asígnele el nombre somerepo

Ahora, para configurar su repositorio para "hablar" con github usando la identidad / credenciales correctas, hemos agregado un control remoto. Suponiendo que su nombre de usuario de github para su nueva cuenta es someuser...

$ git remote add origin github.com-otheruser:someuser/somerepo.git

Esa parte en negrita es absolutamente crítica y debe coincidir con la Hostque definimos en su ~/.ssh/configarchivo

Por último, empuja el repositorio

$ git push origin master

Actualice un repositorio existente para usar una nueva configuración SSH

Digamos que ya tiene algún repositorio clonado, pero ahora desea usar una nueva configuración SSH. En el ejemplo anterior, mantuvimos intactos sus repositorios existentes asignando su par anterior id_rsa/ id_rsa.pubclave aHost github.com su archivo de configuración SSH. No hay nada de malo en esto, pero ahora tengo al menos 5 configuraciones de github y no me gusta pensar en una de ellas como la configuración "predeterminada". Prefiero ser explícito sobre cada una.

Antes de tener esto

Host github.com
  User git
  IdentityFile ~/.ssh/github-mainuser

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

Así que ahora actualizaremos eso (cambios en negrita )

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

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

Pero eso significa que ahora cualquier repositorio existente con un github.comcontrol remoto ya no funcionará con este archivo de identidad. Pero no te preocupes, es una solución simple.

Para actualizar cualquier repositorio existente para usar su nueva configuración SSH, simplemente abra el archivo de configuración git del repositorio y actualice la url.

$ cd existingrepo
$ nano .git/config

Actualice el campo de origen remoto (cambios en negrita )

[remote "origin"]
        url = github.com-mainuser:someuser/existingrepo.git
        fetch = +refs/heads/*:refs/remotes/origin/*

Eso es. Ahora puedes push/ pulla tu gusto


Permisos de archivo de clave SSH

Si tiene problemas con las claves públicas que no funcionan correctamente, SSH es bastante estricto con los permisos de archivo permitidos en su ~/.sshdirectorio y los archivos de claves correspondientes

Como regla general, cualquier directorio debería serlo 700y cualquier archivo debería serlo 600, esto significa que son de solo lectura / escritura del propietario, ningún otro grupo / usuario puede leerlos / escribirlos

$ chmod 700 ~/.ssh
$ chmod 600 ~/.ssh/config
$ chmod 600 ~/.ssh/github-mainuser
$ chmod 600 ~/.ssh/github-mainuser.pub
$ chmod 600 ~/.ssh/github-otheruser
$ chmod 600 ~/.ssh/github-otheruser.pub

Cómo administro mis claves SSH

Administro claves SSH separadas para cada host al que me conecto, de modo que si alguna clave se ve comprometida, no tengo que actualizar las claves en cualquier otro lugar donde haya usado esa clave. Esto es como cuando recibe esa notificación de Adobe de que se robaron 150 millones de la información de sus usuarios, ahora tiene que cancelar esa tarjeta de crédito y actualizar todos los servicios que dependen de ella, lo que es una molestia.

Así ~/.sshes como se ve mi directorio: tengo una .pemclave para cada usuario, en una carpeta para cada dominio al que me conecto. Utilizo .pemclaves para, así que solo necesito un archivo por clave.

$ tree ~/.ssh
/Users/naomik/.ssh
├── config
├── github.com
│   ├── naomik.pem
│   ├── someusername.pem
├── known_hosts
├── naomi.makes.software
│   ├── naomi.pem
├── somedomain.com
│   ├── someuser.pem
└── someotherdomain.org
    └── someuser.pem

Y aquí está mi /.ssh/configarchivo correspondiente : obviamente, las cosas de github son relevantes para responder esta pregunta sobre github, pero esta respuesta tiene como objetivo proporcionarle el conocimiento para administrar sus identidades ssh en cualquier número de servicios / máquinas.

Host github.com-naomik
  HostName github.com
  User git
  IdentityFile ~/.ssh/github.com/naomik.pem

Host github.com-someuser
  HostName github.com
  User git
  IdentityFile ~/.ssh/github.com/someusername.pem

Host naomi.makes.software
  User naomi
  IdentityFile ~/.ssh/naomi.makes.software/naomi.pem

Host somedomain.com
  HostName 162.10.20.30
  User someuser
  IdentityFile ~/.ssh/somedomain.com/someuser.pem

Host someotherdomain.org
  User someuser
  IdentityFile ~/.ssh/someotherdomain.org/someuser.pem

Obtener su clave pública SSH de una clave PEM

Arriba notó que solo tengo un archivo para cada clave. Cuando necesito proporcionar una clave pública, simplemente la genero según sea necesario.

Entonces, cuando github solicite su clave pública ssh, ejecute este comando para generar la clave pública en stdout: copie / pegue donde sea necesario

$ ssh-keygen -y -f someuser.pem
ssh-rsa AAAAB3NzaC1yc2EAAAA...

Tenga en cuenta que este es también el mismo proceso que utilizo para agregar mi clave a cualquier máquina remota. El ssh-rsa AAAA...valor se copia en el ~/.ssh/authorized_keysarchivo del control remoto.


Conversión de sus pares de teclas id_rsa/ id_rsa.puba formato PEM

¿Entonces quiere domesticar sus archivos clave y reducir algunos problemas del sistema de archivos? Convertir su par de claves en un solo PEM es fácil

$ cd ~/.ssh
$ openssl rsa -in id_rsa -outform pem > id_rsa.pem

O, siguiendo nuestros ejemplos anteriores, cambiamos el nombre id_rsa -> github-mainusery id_rsa.pub -> github-mainuser.pub, así

$ cd ~/.ssh
$ openssl rsa -in github-mainuser -outform pem > github-mainuser.pem

Ahora, solo para asegurarse de que hemos convertido esto correctamente, querrá verificar que la clave pública generada coincida con su antigua clave pública

# display the public key
$ cat github-mainuser.pub
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAA ... R++Nu+wDj7tCQ==

# generate public key from your new PEM
$ ssh-keygen -y -f someuser.pem
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAA ... R++Nu+wDj7tCQ==

Ahora que tiene su github-mainuser.pemarchivo, puede eliminar de forma segura sus archivos antiguos github-mainusery github-mainuser.pub, solo es necesario el archivo PEM; solo genera la clave pública cuando la necesites ^ _ ^


Crear claves PEM desde cero

No necesita crear el par de claves privada / pública y luego convertir a una sola clave PEM. Puede crear la clave PEM directamente.

Vamos a crear un newuser.pem

$ openssl genrsa -out ~/.ssh/newuser.pem 4096

Obtener la clave pública SSH es lo mismo

$ ssh-keygen -y -f ~/.ssh/newuser.pem
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACA ... FUNZvoKPRQ==

2
Entiendo que esta es una vieja pregunta, pero eso no excusa el hecho de que casi todas las respuestas aquí dependen de un enlace a algún tutorial y, por lo tanto, están sujetas a la descomposición del enlace. Está bien vincular fuentes / citas, pero no puede apoyarse en un enlace si no resume los bits críticos en su respuesta publicada aquí.
Gracias

Voté su excelente y detallada respuesta porque es claramente la forma correcta de hacerlo. Mi problema con esto es que es complejo, y después de algunos años de usar algunas cuentas, obtengo una nueva, luego no puedo recordar cómo hacerlo "de la manera correcta". Mi camino a continuación es muy simple: solo creo 3 nuevos archivos y un nuevo script, y estoy listo para comenzar. Me funcionó perfectamente durante muchos años. Los lectores pueden decidir qué funciona mejor para ellos.
David H

DavidH Agradezco el comentario. La respuesta se siente compleja si la tomas como un todo, pero el lector realmente solo necesita preocuparse por una pequeña porción de la respuesta si su único objetivo es agregar otra identidad github: todas las porciones restantes de la Las respuestas están destinadas a configurarlo con una solución robusta para administrar claves SSH en general, y son completamente opcionales.
Gracias

Creo que git clone github.com-otheruser:someorg/somerepo.gitdebe ser git clone git@github.com-otheruser:someorg/somerepo.git(agregando el git@). Al menos, eso es lo que necesitaba.
CommonsWare

@CommonsWare todas las opciones de línea de comandos, como especificar el usuario, también se pueden hacer en la configuración SSH. Por ejemplo: Host github.com(nueva línea) User git(nueva línea)IdentityFile ...
Gracias el

24

Al crear diferentes alias de host para github.com en su ~ / .ssh / config, y dar a cada alias de host su propia clave ssh, puede usar fácilmente varias cuentas de github sin confusión. Esto se debe a que github.com se distingue no por el usuario, que siempre es solo git, sino por la clave ssh que usó para conectarse. Simplemente configure sus orígenes remotos utilizando sus propios alias de host ".

El resumen anterior es cortesía de los comentarios en la publicación del blog a continuación.

He encontrado esta explicación la más clara. Y funciona para mí, al menos a partir de abril de 2012.

http://net.tutsplus.com/tutorials/tools-and-tips/how-to-work-with-github-and-multiple-accounts/


1
Probablemente también deba ejecutar $ ssh-add ~/.ssh/id_rsa_COMPANY: consulte Error: Permiso denegado (clave pública) - Documentación del usuario
Pat

22

Los detalles en http://net.tutsplus.com/tutorials/tools-and-tips/how-to-work-with-github-and-multiple-accounts/ vinculados por mishaba me funcionan muy bien.

De esa página:

$ touch ~/.ssh/config

Luego edite ese archivo para que sea algo como esto (una entrada por cuenta):

#Default GitHub
Host github.com
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_rsa

Host github-COMPANY
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_rsa_COMPANY

8
También me gustaría tener en cuenta que "github.com" o "github-COMPANY" tendrían que usarse al hacer un clon (y probablemente otros comandos) git clone git@github-COMPANY/repo/name.gitpara obtener la clave ssh correcta.
hellatan

@dtan: ¿Cómo implementaría esto si tuviera que clonar sobre https? git clone https://github-COMPANY/GitUserName/projectname.gitno parece funcionar La clave predeterminada que usa github.com funciona bien.
Isaac Nequittepas

1
@IsaacRemuant, ¿tienes que revisar https? Cada vez que desee tirar / empujar, debe ingresar sus credenciales de usuario. Sería mejor si pudieras hacer git: //github-COMPANY...projectname.git. ¿Hay algún mensaje de error para la llamada https?
hellatan

@dtan: He tenido algunos problemas con el puerto 22 a pesar de que aparentemente me han abierto. ssh: connect to host github.com port 22: Bad file number fatal: The remote end hung up unexpectedly. https era la única forma hasta ahora. $ git clone https://github-USER/UserName/test_project_user.git Cloning into test_project_user... error: Couldn't resolve host 'github-USER' while accessing https://github-USER/N UserName/test_project_user.git/info/refs fatal: HTTP request failed No estoy seguro de si puede estar relacionado con el archivo de configuración o la forma en que estoy tratando de emular su llamada git con https.
Isaac Nequittepas

En última instancia, haré un análisis en profundidad intentando todo y lo publicaré apropiadamente como una pregunta.
Isaac Nequittepas

13
  • Ir a ~ / .ssh
  • Cree un archivo llamado config (no tiene extensión)
  • Abra el archivo de configuración y agregue los siguientes códigos. (cambio de acuerdo a su cuenta)

    1. Cuenta 1

      # account_1
      Host gitlab.com-account_1
      HostName gitlab.com
      User git
      PreferredAuthentications publickey
      IdentityFile ~/.ssh/id_rsa_account_1
      
    2. Cuenta 2

      # Account2
      Host gitlab.com-Account2
      HostName gitlab.com
      User git
      PreferredAuthentications publickey
      IdentityFile ~/.ssh/id_rsa_Account2
      
    3. Cuenta 3

      # Account_3
      Host github.com-Account3
      HostName github.com
      User git
      PreferredAuthentications publickey
      IdentityFile ~/.ssh/id_rsa_Account_3
      
  • Agregue la URL remota de la siguiente manera

    1. Cuenta 1

      git remote add origin git@gitlab.com-account_1:group_name/repo_name.git
      
    2. Cuenta 2

      git remote add origin git@gitlab.com-Account2:group_name/repo_name.git
      
    3. Cuenta 3

      git remote add origin github.com-Account3:github_username/repo_name.git
      

Asegúrese de que los nombres de IdentityFile sean los mismos que creó durante la generación de claves ssh.


¿Podría explicar por qué lo usa PreferredAuthentications publickey?
Oliver Pearmain

@OliverPearmain Aquí le digo a ssh que nuestro método preferido para la autenticación es publickey. Puede usar la contraseña en Autenticaciones preferidas, pero es posible que deba ingresar una contraseña para la autenticación.
Pranav VR

1
Agradezco la respuesta @Pranav VR, parece que quiero usar lo mismo :-)
Oliver Pearmain

11

Uso scripts de shell para cambiarme a la cuenta que quiera que esté "activa". Esencialmente, comienza desde un nuevo comienzo, configura una cuenta correctamente y funciona, luego mueve estos archivos a un nombre con el prefijo adecuado. A partir de entonces, puede usar el comando "github" o "gitxyz" para cambiar:

# my github script
cd ~/.ssh

if [ -f git_dhoerl -a -f git_dhoerl.pub -a -f config_dhoerl ]
then
    ; 
else 
    echo "Error: missing new files"
    exit 1
fi 

# Save a copy in /tmp, just in case
cp id_rsa /tmp
cp id_rsa.pub /tmp
cp config /tmp
echo "Saved old files in /tmp, just in case"

rm id_rsa
rm id_rsa.pub
rm config
echo "Removed current links/files"

ln git_dhoerl id_rsa
ln git_dhoerl.pub id_rsa.pub
ln config_dhoerl config

git config --global user.email "dhoerl@<company>.com"
git config --global github.user "dhoerl"        
git config --global github.token "whatever_it_is"

ssh-add -D

He tenido mucha suerte con esto. También creé un script de ejecución en Xcode (para ustedes, usuarios de Mac) para que no compilara mi proyecto a menos que tuviera la configuración adecuada (ya que usa git):

Ejecutar script colocado después de dependencias (usando / bin / ksh como shell):

if [ "$(git config --global --get user.email)" != "dhoerl@<company>.com" ]
then
    exit 1
fi

EDITAR: se agregaron pruebas para la existencia de nuevos archivos y se copiaron archivos antiguos a / tmp para abordar los comentarios de @naomik a continuación.


Tenga cuidado al publicar copiar y pegar respuestas repetitivas / textuales a múltiples preguntas, la comunidad suele marcarlas como "spam". Si está haciendo esto, generalmente significa que las preguntas son duplicadas, así que márquelas como tales en su lugar: stackoverflow.com/questions/7548158 , stackoverflow.com/questions/3225862 , stackoverflow.com/questions/7924937
Kev

1
Esto es una pesadilla. Si alguien ejecutara este script antes de comprender que sus claves id_rsay id_rsa.pubse eliminarían, podrían quedar bloqueadas del control remoto.
Gracias

@naomik actualizó el script para verificar primero si hay archivos nuevos y para guardar archivos antiguos en / tmp
David H

10

Esta respuesta es para principiantes (no git gurus) . Recientemente tuve este problema y tal vez soy solo yo, pero la mayoría de las respuestas parecían requerir una comprensión bastante avanzada de git. Después de leer varias respuestas de desbordamiento de pila, incluido este hilo, estos son los pasos que necesitaba seguir para cambiar fácilmente entre cuentas de GitHub (por ejemplo, suponga dos cuentas de GitHub, github.com/personal y gitHub.com/work ):

  1. Verifique las claves ssh existentes: abra la Terminal y ejecute este comando para ver / enumerar losls -al ~/.ssh
    archivos declaves ssh existentescon la extensión.pubson sus claves ssh, por lo que debe tener dos para lascuentaspersonalywork. Si solo hay uno o ninguno, es hora de generar otro sabio, omita esto.

    - Generación de clave ssh : inicie sesión en github (ya sea personal o laboral), navegue a Configuración y copie el correo electrónico asociado.
    ahora regrese a la Terminal y ejecutessh-keygen -t rsa -C "the copied email", verá:

    Generar pares de claves rsa públicas / privadas.
    Ingrese el archivo en el que guardará la clave (/.../.ssh/id_rsa):


    id_rsa es el nombre predeterminado para la clave ssh que pronto se generará, así que copie la ruta y cambie el nombre de la predeterminada, p. Ej. /.../.ssh/id_rsa_worksi se genera por cuenta de trabajo. proporcione una contraseña o simplemente ingrese para ignorar y, leerá algo como La imagen randomart de la clave es: y la imagen. hecho.
    Repita este paso una vez más para su segunda cuenta de github. Asegúrese de utilizar la dirección de correo electrónico correcta y un nombre de clave ssh diferente (por ejemplo, id_rsa_personal) para evitar sobrescribir.
    En esta etapa, debería ver dos teclas ssh cuando ls -al ~/.sshvuelva a ejecutarse .
  2. Asociar la clave ssh con la cuenta gitHub: el siguiente paso es copiar una de las claves ssh, ejecutar esto pero reemplazando su propio nombre de clave ssh:, pbcopy < ~/.ssh/id_rsa_work.pubreemplace id_rsa_work.pubcon lo que llamó el suyo.
    Ahora que nuestra llave ssh se copia al portapapeles, volver a la cuenta de GitHub [Asegúrese de que está conectado a la cuenta de trabajo si la clave ssh es que ha copiado id_rsa_work] y vaya a
    Configuración - SSH y las llaves GPG y haga clic en la tecla New SSH botón (no Nueva clave GPG por cierto: D)
    asigne un título para esta clave, pegue la clave y haga clic en Agregar clave SSH. Ahora ha agregado con éxito la clave ssh o notó que ha estado allí todo el tiempo, lo cual está bien (o recibió un error porque seleccionó Nueva clave GPG en lugar deNueva clave SSH : D).
  3. Asociar la clave ssh con la cuenta gitHub : repita el paso anterior para su segunda cuenta.
  4. Edite la configuración global de git: el último paso es asegurarse de que el archivo de configuración global conozca todas las cuentas de github (por así decirlo).
    Ejecute git config --global --editpara editar este archivo global, si esto abre vim y no sabe cómo usarlo, presione ipara ingresar al modo Insertar, edite el archivo como se muestra a continuación y presione esc seguido de :wqpara salir del modo insertar:

    [inside this square brackets give a name to the followed acc.] name = github_username email = github_emailaddress [any other name] name = github_username email = github_email [credential] helper = osxkeychain useHttpPath = true

¡Listo! Ahora, cuando intente empujar o extraer de un repositorio, se le preguntará qué cuenta de GitHub debe vincularse con este repositorio y se le preguntará solo una vez, la configuración local recordará este enlace y no la configuración global para que pueda trabajar en diferentes repos que están vinculados con diferentes cuentas sin tener que editar la configuración global cada vez.


Deben permitir etiquetas para respuestas, esto es para Mac OS.
user4015990

5

Solución más simple y fácil para evitar confusiones.

Para que los usuarios de Windows utilicen múltiples o diferentes cuentas git para diferentes proyectos.

Siguientes pasos: vaya al Panel de control y busque Credential Manager. Luego vaya al Administrador de credenciales -> Credenciales de Windows

Ahora elimine el nodo git: https // github.com bajo Encabezado de credenciales genéricas

Esto eliminará las credenciales actuales. Ahora puede agregar cualquier proyecto a través de git pull, le pedirá nombre de usuario y contraseña.

Cuando tenga algún problema con otra cuenta, realice el mismo proceso.

Gracias

referirse a la imagen


4

acabo de descubrir esto para Windows, usando credenciales para cada repositorio:

cd c:\User1\SomeRepo
git config --local credential.https://github.com.user1 user1
git config --local credential.useHttpPath true
git config --local credential.helper manager
git remote set-url origin https://USERNAME@github.com/USERNAME/PROJECTNAME.git

El formato de credencial. https://github.com . le dice al ayudante de credenciales la URL de la credencial. El 'useHttpPath' le dice al administrador de credenciales que use la ruta para la credencial. Si se omite useHttpPath, el administrador de credenciales almacenará una credencial para https://github.com . Si está incluido, el administrador de credenciales almacenará múltiples credenciales, que es lo que realmente quería.


2

Encontré esta gema muy útil: sshwitch

https://github.com/agush22/sshwitch
http://rubygems.org/gems/sshwitch

Ayuda a cambiar las claves ssh. ¡Recuerde hacer una copia de seguridad de todo primero!

También para asegurarme de que los commits tengan la dirección de correo electrónico correcta asociada con ellos, me aseguré de que el archivo ~ / .gitconfig tuviera la dirección de correo electrónico adecuada.


2

Además de crear múltiples claves SSH para varias cuentas, también puede considerar agregar colaboradores en cada proyecto utilizando los mismos correos electrónicos de la cuenta y almacenar la contraseña de forma permanente.

#this store the password permanently
$ git config --global credential.helper wincred

He configurado varias cuentas con diferentes correos electrónicos y luego puse el mismo usuario y correo electrónico en cada cuenta como uno de los colaboradores. De esta manera, puedo acceder a todas las cuentas sin agregar la clave SSH o cambiar a otro nombre de usuario y enviar un correo electrónico para la autenticación.


2

El enfoque más sencillo y directo (en mi humilde opinión): no hay archivos de configuración ni demasiadas molestias

Simplemente cree otra clave ssh.

Digamos que tiene una nueva cuenta de trabajo de GitHub, solo cree una nueva clave para ella:

sh-keygen -t rsa -C "email@work_mail.com" -f "id_rsa_work_user1"`

Ahora debería tener el antiguo y el nuevo, para verlos, ejecute:

ls -al ~/.ssh

Necesita ejecutar lo anterior solo una vez.

A partir de ahora, cada vez que desee cambiar entre los dos, simplemente ejecute:

ssh-add -D
ssh-add ~/.ssh/id_rsa_work_user1 #make to use this without the suffix .pub

Para cambiar al anterior, vuelva a ejecutar:

 ssh-add -D
 ssh-add ~/.ssh/<previous id_rsa>

1

Otra forma más fácil es usar múltiples aplicaciones de escritorio, como lo que estoy haciendo, usar la cuenta A en el escritorio de Github, mientras uso la cuenta B en Github Kraken



1

En caso de que no desee meterse con el ~/.ssh/configarchivo mencionado aquí, puede ejecutar git config core.sshCommand "ssh -i ~/.ssh/custom_id_rsa"en el repositorio donde desea comprometerse desde una cuenta diferente.

El resto de la configuración es la misma:

  1. Cree una nueva clave SSH para la segunda cuenta con ssh-keygen -t rsa -f ~/.ssh -f ~/.ssh/custom_id_rsa

  2. Inicie sesión en github con su otra cuenta, vaya a https://github.com/settings/keys y pegue el contenido de~/.ssh/custom_id_rsa.pub

  3. Asegúrese de estar usando SSH en lugar de HTTPS como URL remota: git remote set-url origin git@github.com:upstream_project_teamname/upstream_project.git



0

A diferencia de otras respuestas, donde debe seguir algunos pasos para usar dos cuentas de github diferentes desde la misma máquina, para mí funcionó en dos pasos .

Solo necesitas:

1) genere un par de claves SSH pública y privada para cada una de sus cuentas en ~/.sshubicación con diferentes nombres y

2) agregue las claves públicas generadas a la cuenta respectiva en Settings>> SSH and GPG keys>>New SSH Key .

Para generar los pares de claves públicas y privadas SSH, use el siguiente comando:

cd ~/.ssh
ssh-keygen -t rsa -C "email@work.com" -f "id_rsa_WORK"
ssh-keygen -t rsa -C "email@gmail.com" -f "id_rsa_PERSONAL"

Como resultado de los comandos anteriores, id_rsa_WORKy id_rsa_WORK.publos archivos serán creados para su trabajo cuenta (ex - git.work.com) y id_rsa_PERSONALy id_rsa_PERSONAL.pubse creará para su personal cuenta (ex - github.com).

Una vez creado, copie el contenido de cada *.pubarchivo public ( ) y realice el Paso 2 para cada cuenta.

PD : No es necesario hacer una entrada de host para cada cuenta git bajo el ~/.ssh/configarchivo como se menciona en otras respuestas, si el nombre de host de sus dos cuentas es diferente.


¿Cómo cambia entre las dos cuentas en su PC local?
user4015990

1
No hay necesidad de cambiar. Cada vez que clones un repositorio en local, el git guardará la información de la cuenta en tu repositorio local. Por lo tanto, cada vez que haga un git push o pull dentro del repositorio local, la configuración anterior detectará qué cuenta considerar.
Sahil Chhabra

0

Si tiene WSL instalado, puede tener dos cuentas git separadas: una en WSL y otra en Windows.


0

Debe y no debe empujar al proyecto con algunas credenciales comunes. Una vez que comience en una nueva máquina, siga los siguientes pasos para configurar y usar correctamente sus credenciales de gitlab:

  • crear las claves ssh públicas / privadas en la máquina
  • copie y pegue la clave pública en la interfaz de usuario de gitlab / github (cualquiera que sugiera cómo hacerlo a través de la línea cmd obtiene una cerveza gratis ...)
  • asegúrese de clonar el repositorio a través de git y no http url
  • configura el alias git para evitar escribir constantemente el mismo prefijo para el comando git
  • durante git commit SIEMPRE use el autor y las banderas de correo electrónico
  • usa git como lo harías normalmente

Todo esto de la siguiente manera:

 # create the public / private key credentials on that specific machine
 ssh-keygen -t rsa -b 4096 -C "<<you>>@org.net" -f ~/.ssh/id_rsa.<<you>>.`hostname -s`

 # setup your public key in the gitlab ui 
 cat ~/.ssh/id_rsa.<<you>>.`hostname -s`

 # make sure you clone the repo via the git and not http url
 git clone git@git.in.org.net:org/some-repo.git

 # set the git alias to avoid constant typing of the repeating prefix to the git cmd
 alias git='GIT_SSH_COMMAND="ssh -i ~/.ssh/id_rsa.<<you>>.`hostname -s`" git'

 # during git commit ALWAYS use the author and e-mail flags
 git add --all ; git commit -nm "$git_msg" --author "YourFirstName YourLastName <you@phz.fi>"

 # use git as normal
 git fetch --all; git pull --all 

0
  1. Navegue al directorio en el que desea enviar sus cambios a una cuenta de GitHub diferente.
  2. Cree una nueva clave SSH en su terminal / línea de comando.

    ssh-keygen -t rsa -C "su dirección de correo electrónico"

  3. A continuación se mostrará lo siguiente:

    Generando pares de claves rsa públicas / privadas. Ingrese el archivo en el que guardará la clave (/home/your_username/.ssh/id_rsa):

Copie y pegue la ruta seguida de un nombre identificable para el archivo:

/home/your_username/.ssh/id_rsa_personal

4) Luego le pedirá lo siguiente:

Enter passphrase (empty for no passphrase):
Enter same passphrase again:

5) Ahora puede escribir el siguiente comando para ver todas las claves SSH que tiene en su máquina local:

ls -al ~/.ssh

Debería poder ver su nuevo archivo de clave SSH. Como puede ver en mi cuenta, tengo tanto id_rsa_test como id_rsa_personal.pub.

drwx------  2 gmadmin gmadmin 4096 Nov 16 22:20 .
drwxr-xr-x 42 gmadmin gmadmin 4096 Nov 16 21:03 ..
-rw-------  1 gmadmin gmadmin 1766 Nov 16 22:20 id_rsa_personal
-rw-r--r--  1 gmadmin gmadmin  414 Nov 16 22:20 id_rsa_personal.pub
-rw-r--r--  1 gmadmin gmadmin  444 Nov  6 11:32 known_hosts

6) A continuación, debe copiar la clave SSH que se almacena en el archivo id_rsa_personal.pub. Puede abrir esto en el editor de texto de su elección. Actualmente estoy usando Atom, así que abrí el archivo con el siguiente comando:

atom ~/.ssh/id_rsa_personal.pub

Luego obtendrá algo similar a esto:

Intantidades

7) Copie esto y navegue a su cuenta de GitHub → Configuración → SSH y claves GPG 8) Haga clic en Nueva clave SSH. Copie la clave, asígnele un título y agréguela. 9) Agregar clave desde la terminal

ssh-add ~/.ssh/id_rsa_personal
Enter passphrase for /home/your_username/.ssh/id_rsa_personal: 

10) Configurar usuario y contraseña.

git config --global user.name "gitusername"
git config --global user.email "gitemail"

11) Estamos listos para comprometernos y presionar ahora.

git init
git add .
git commit 
git push

0

Si ha creado o clonado otro repositorio y no ha podido extraer originoupstream agregar la clave ssh en ese directorio con el siguiente comando funcionó.

Este es el error que estaba recibiendo aquí:

Warning: Permanently added the RSA host key for IP address '61:fd9b::8c52:7203' to the list of known hosts.
Permission denied (publickey).
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.

Usé el siguiente comando, esto funciona:

ssh-add ~/.ssh/id_rsa_YOUR_COMPANY_NAME

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.