usuario lav cambiar git version-control github

lav - git ab



¿Varias cuentas de github en la misma computadora? (15)

Tratando de trabajar en mis dos repositorios de "trabajo", y mis repositorios personales en git hub, desde mi computadora.

La cuenta de trabajo se configuró primero, y todo funciona perfectamente.

Sin embargo, parece que mi cuenta personal no se puede enviar a mi repositorio personal, que se configura en una cuenta / correo electrónico diferente.

He intentado copiar mi clave de trabajo en mi cuenta personal, pero eso produce un error, porque, por supuesto, solo se puede adjuntar una clave a una cuenta.

¿Cómo puedo ingresar y salir de ambas cuentas desde sus respectivas credenciales de github?

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

Solo necesitas:

1) genere un par de claves públicas y privadas SSH para cada una de sus cuentas en la ubicación ~/.ssh con diferentes nombres y

2) agregue las claves públicas generadas a la cuenta correspondiente 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 protected]" -f "id_rsa_WORK" ssh-keygen -t rsa -C "[email protected]" -f "id_rsa_PERSONAL"

Como resultado de los comandos anteriores, se id_rsa_WORK archivos id_rsa_WORK e id_rsa_WORK.pub para su cuenta de trabajo (ex - git.work.com) e id_rsa_PERSONAL y id_rsa_PERSONAL.pub se crearán para su cuenta personal (ex - github.com).

Una vez creado, copie el contenido de cada archivo público ( *.pub ) y realice el Paso 2 para cada cuenta.

PD : no es necesario realizar una entrada de host para cada cuenta de git en el archivo ~/.ssh/config como se menciona en otras respuestas, si el nombre de host de sus dos cuentas es diferente.

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 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 coloco el mismo usuario y correo electrónico en cada cuenta que 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 correo electrónico para la autenticación.

Al crear diferentes alias de host para github.com en su ~ / .ssh / config, y al asignar 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 no distingue por usuario, lo que siempre es solo git, sino por la tecla ssh que usaste para conectarte. 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 más clara. Y me funciona, al menos a partir de abril de 2012.

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

Encontré esta gema muy útil: sshwitch

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

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

También para asegurarme de que las confirmaciones tengan la dirección de correo electrónico correcta asociada con ellas, me aseguré de que el archivo ~ / .gitconfig tuviera la dirección de correo electrónico correcta.

Esta respuesta es para principiantes (gurús no-git) . Hace poco tuve este problema y quizás solo sea yo, pero la mayoría de las respuestas parecían requerir un entendimiento más avanzado de git. Después de leer varias respuestas de desbordamiento de pila que incluyen este hilo, aquí están los pasos que debo seguir para cambiar fácilmente entre las cuentas de GitHub (por ejemplo, supongamos dos cuentas de GitHub, github.com/personal y gitHub.com/work ):

  1. Verifique las claves ssh existentes: abra Terminal y ejecute este comando para ver / listar las claves ssh existentes ls -al ~/.ssh
    los archivos con extensión .pub son sus claves ssh, por lo que debe tener dos para las cuentas personal y work . Si solo hay uno o ninguno, es hora de generar lo contrario, omita esto.

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

    Generando par de claves rsa públicas / privadas.
    Introduzca el archivo en el que se 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 del predeterminado, por ejemplo, /.../.ssh/id_rsa_work si se genera para la cuenta de trabajo. proporcione una contraseña o simplemente ingrese para ignorar y, leerá algo como La imagen aleatoria de la clave es: y la imagen. hecho.
    Repita este paso una vez más para su segunda cuenta de github. Asegúrese de usar la dirección de correo electrónico correcta y un nombre de clave ssh diferente (por ejemplo, id_rsa_personal) para evitar la sobrescritura.
    En esta etapa, debería ver dos teclas ssh cuando ejecute ls -al ~/.ssh nuevamente.
  2. Asocie la clave ssh a la cuenta de gitHub: el siguiente paso es copiar una de las claves ssh, ejecute esto pero sustituya su propio nombre de clave ssh: pbcopy < ~/.ssh/id_rsa_work.pub , reemplace id_rsa_work.pub con lo que llamó tuyo.
    Ahora que nuestra clave ssh se ha copiado al portapapeles, vuelva a la cuenta de github [Asegúrese de haber iniciado sesión en la cuenta de trabajo si la clave ssh que copió es id_rsa_work ] y navegue hasta
    Configuración: claves SSH y GPG y haga clic en el botón Nueva clave SSH (no en Nueva clave GPG por cierto: D)
    asigne un título a esta clave, pegue la clave y haga clic en Agregar clave SSH. Ya ha agregado exitosamente la clave ssh o ha notado que ha estado allí todo el tiempo, lo que está bien (o ha recibido un error porque seleccionó Nueva clave GPG en lugar de Nueva clave SSH : D).
  3. Asocie la clave ssh con la cuenta de 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 conoce todas las cuentas de github (por así decirlo).
    Ejecute git config --global --edit para editar este archivo global, si esto abre vim y no sabe cómo usarlo, presione i para ingresar al modo Insertar, edite el archivo como se muestra a continuación y presione esc seguido de :wq para salir del modo de inserción:

    [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 enviar o extraer un repositorio, se le preguntará qué cuenta de GitHub debe vincularse con este repositorio y se le solicita 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 vinculadas con diferentes cuentas sin tener que editar la configuración global cada vez.

Gracias usuario1107028:

Utilice HTTPS:

cambiar la url remota a https:

git remote set-url origin https://[email protected]/USERNAME/PROJECTNAME.git y está listo:

git push

Encontré esto de la mejor manera al usar varias cuentas de github. No puedo usar una sola cuenta, simplemente no es posible, y no puedo lograr que SSH se comporte, no importa lo que hice. Habría votado la respuesta pero no tengo suficientes puntos. Quería reconocer esta sencilla solución para aquellos que, como yo, necesitan una solución limpia y fácil. Funcionó por primera vez y me ahorró horas más de lucha.

No tienes que mantener dos cuentas diferentes para personal y trabajo. De hecho, Github recomienda que mantengas una cuenta única y te ayuda a combinar ambas.

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

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

Otra forma más fácil es usar varias 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

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

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

Siguiendo los pasos: Vaya al Panel de control y busque Credential Manager. Luego vaya a Administrador de credenciales -> Credenciales de Windows

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

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

Cuando te enfrentas a algún problema con otra cuenta haz el mismo proceso.

Gracias

referirse a la imagen

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

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

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

Espero que esto ayude.

EDITAR: Enlaces actualizados

Utilice HTTPS:

cambiar la url remota a https:

git remote set-url origin https://[email protected]/USERNAME/PROJECTNAME.git

y eres bueno para ir

git push

Para asegurarse de que las confirmaciones aparecen como realizadas por USERNAME, también puede configurar user.name y user.email para este proyecto:

git config user.name USERNAME git config user.email [email protected]

Utilizo los scripts de shell para cambiarme a cualquier cuenta que quiera que esté "activa". Esencialmente, comienza de nuevo, obtiene una cuenta configurada correctamente y funciona, luego mueve estos archivos a un nombre con el prefijo adecuado. A partir de entonces, puede utilizar 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 los usuarios de Mac), por lo que no compilaría mi proyecto a menos que tuviera la configuración adecuada (ya que usa git):

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

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

EDITAR: agregue pruebas para la existencia de nuevos archivos y copie los archivos antiguos en / tmp para abordar el comentario de @naomik a continuación.

Ponerse en forma

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

Pero antes de que podamos comenzar a empujar / arrastrar repositorios con su segunda identidad, debemos ponerlo en forma. Supongamos que su sistema está configurado con un par de claves id_rsa e id_rsa.pub típicas. En este momento su tree ~/.ssh ve 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 usa para qué usuario / 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, vamos a generar un nuevo par de claves : aquí github-otheruser la nueva clave github-otheruser

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

Ahora, cuando miramos el tree ~/.ssh vemos

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

A continuación, necesitamos configurar un archivo ~/.ssh/config que definirá nuestras configuraciones clave. Lo crearemos con los permisos adecuados de 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

Es de suponer que tendrás algunos repositorios asociados con tu identidad de github principal. Por esa razón, el Host github.com "predeterminado" está configurado para usar su clave de mainuser principal. Si no desea favorecer una cuenta sobre otra, le mostraré cómo actualizar los 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 el contenido de la clave pública utilizando: copiar / pegar en github

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

Ahora su nueva identidad de usuario está completamente configurada. A continuación, le mostraremos cómo usarla.

Hacer las cosas: clonar un repositorio

Entonces, ¿cómo se une esto para trabajar con git y github? Bueno, porque no puedes tener un pollo sin huevo, veremos cómo clonar 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/somerepo ya 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 nombre del Host que configuramos en su archivo ~/.ssh/config . Eso conecta correctamente git al archivo de IdentityFile correspondiente y lo autentica correctamente con github

Haciendo cosas: creando un nuevo repositorio

Bueno, porque no puedes tener una gallina sin un huevo, veremos la publicación de un nuevo repositorio en tu cuenta secundaria. Esta situación se aplica a los usuarios que crean contenido nuevo con su cuenta secundaria de github.

Supongamos que ya has hecho un pequeño trabajo localmente y ahora estás listo para empujar a Github. Puedes seguir conmigo si quieres

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

Ahora configura este repositorio para usar tu identity

$ git config user.name "Mister Manager" $ git config user.email "[email protected]"

Ahora haz tu primer commit

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

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

$ git log --pretty="%H %an <%ae>" f397a7cfbf55d44ffdf87aa24974f0a5001e1921 Mister Manager <[email protected]>

Muy bien, es hora de empujar a github! Ya que github aún no conoce nuestro nuevo repositorio, primero vaya a github.com/new y cree su nuevo repositorio - llámelo somerepo

Ahora, para configurar su repo para "hablar" con github usando la identidad / credenciales correctas, hemos agregado un control remoto. Asumiendo que tu nombre de usuario de Github para tu nueva cuenta es algún usuario ...

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

Esa parte en negrita es absolutamente crítica y debe coincidir con el Host que definimos en su archivo ~/.ssh/config

Por último, empujar el repositorio.

$ git push origin master

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

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

Antes teniamos 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 vamos a actualizar eso a (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.com remoto de github.com 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

Actualizar 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 / pull al contenido de tu corazón

Permisos de archivo de clave SSH

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

Como regla general, los directorios deben ser 700 y los archivos deben ser 600 (esto significa que son de lectura / escritura de propietario), ningún otro grupo / usuario puede leerlos o 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 gestiono mis claves SSH

Administro claves SSH independientes para cada host al que me conecto, de modo que si alguna de las claves se ve comprometida, no tengo que actualizar las claves en ningún otro lugar donde haya usado esa clave. Esto es como cuando recibe la 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.

~/.ssh es como se ve mi directorio ~/.ssh : Tengo una clave .pem para cada usuario, en una carpeta para cada dominio al que me conecto. .pem claves .pem para que solo necesite 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 correspondiente archivo /.ssh/config : obviamente, el tema de github es relevante para responder a esta pregunta sobre github, pero esta respuesta apunta a brindarle 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

Obteniendo su clave pública SSH de una clave PEM

Arriba notaste 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 enviar la clave pública a la salida estándar - 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 valor ssh-rsa AAAA... se copia al archivo ~/.ssh/authorized_keys del control remoto

Convertir sus pares de claves id_rsa / id_rsa.pub a formato PEM

¿Así que quieres domesticar tus archivos clave y reducir algunos archivos del sistema de archivos? Convertir su par de claves a 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 de id_rsa -> github-mainuser y id_rsa.pub -> github-mainuser.pub - so

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

Ahora solo para asegurarse de que hayamos 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 archivo github-mainuser.pem , puede eliminar de forma segura sus antiguos github-mainuser y github-mainuser.pub ; solo es necesario el archivo PEM; solo genera la clave pública cuando la necesites ^ _ ^

Creación de claves PEM desde cero

No es necesario crear el par de claves privada / pública y luego convertir en 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 la misma

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

  • Ir a ~ / .ssh
  • Crea un archivo llamado config (no tiene extensión)

  • Abra el archivo de configuración y agregue los siguientes códigos. (cambiar 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 [email protected]_1:group_name/repo_name.git

    2. Cuenta 2

      git remote add origin [email protected]: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.