¿Múltiples cuentas github en la misma computadora?

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?

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

• Este enlace es fácil de seguir (Gracias Eric): http://code.tutsplus.com/tutorials/quick-tip-how-to-work-with-github-and-multiple-accounts--net-22574

• Generación de claves SSH (Win / msysgit) https://help.github.com/articles/generating-an-ssh-key/

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.

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

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==

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/

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

• 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.

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.

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.

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

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.

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.

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.

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>

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

IntelliJ Idea tiene soporte integrado de esa https://www.jetbrains.com/help/idea/github.html#da8d32ae

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

No tiene que mantener dos cuentas diferentes para personal y trabajo. De hecho, Github te recomienda mantener una sola cuenta y te ayuda a fusionar ambas.

Siga el siguiente enlace para fusionarse si decide que no es necesario mantener varias cuentas.

https://help.github.com/articles/merging-multiple-user-accounts/

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.

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

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 

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

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