Cómo administrar múltiples cuentas de GitHub en una sola máquina con claves SSH

La necesidad de administrar varias cuentas de GitHub en la misma máquina surge en algún momento para la mayoría de los desarrolladores. Cada vez que cambio mi Mac o necesito Git push con una nueva cuenta de trabajo, termino navegando por los procedimientos de algo que he hecho más de media docena de veces.

Mi pereza al no documentar el proceso y mi incapacidad para recordar los pasos me hace pasar una cantidad decente de tiempo obteniendo los fragmentos de toda la web y luego de alguna manera hacerlo funcionar.

Estoy seguro de que hay muchos de ustedes que han estado allí, hecho eso y muchos más de ustedes que están esperando la próxima vez que ocurra lo mismo (¡yo incluido!). Este esfuerzo está destinado a ayudarnos a todos.

1. Generando las claves SSH

Antes de generar una clave SSH, podemos verificar si tenemos alguna clave SSH existente: ls -al ~/.sshEsto enumerará todos los pares de claves públicas y privadas existentes, si corresponde.

Si ~/.ssh/id_rsaestá disponible, podemos reutilizarlo, o de lo contrario, primero podemos generar una clave a la predeterminada ~/.ssh/id_rsaejecutando:

ssh-keygen -t rsa

Cuando se le solicite la ubicación para guardar las claves, acepte la ubicación predeterminada presionando Intro. Se ~/.ssh/id_rsa.pubcreará una clave privada y una clave pública en la ubicación ssh predeterminada ~/.ssh/.

Usemos este par de claves predeterminado para nuestra cuenta personal.

Para las cuentas de trabajo, crearemos diferentes claves SSH. El siguiente código generará las claves SSH y guardará la clave pública con la etiqueta "[email protected]_mail.com" para~/.ssh/id_rsa_work_user1.pub

$ ssh-keygen -t rsa -C "[email protected]_mail.com" -f "id_rsa_work_user1" 

Tenemos dos claves diferentes creadas:

~/.ssh/id_rsa ~/.ssh/id_rsa_work_user1

2. Agregar la nueva clave SSH a la cuenta de GitHub correspondiente

Ya tenemos las claves públicas SSH listas, y pediremos a nuestras cuentas de GitHub que confíen en las claves que hemos creado. Esto es para deshacerse de la necesidad de escribir el nombre de usuario y la contraseña cada vez que realiza un push de Git.

Copie el pbcopy < ~/.ssh/id_rsa.pub de clave pública y luego inicie sesión en su cuenta personal de GitHub:

  1. Ir Settings
  2. Seleccione SSH and GPG keysdel menú de la izquierda.
  3. Haga clic en New SSH key, proporcione un título adecuado y pegue la clave en el cuadro a continuación
  4. Haga clic Add keyy listo.
Para las cuentas de trabajo, use las claves públicas correspondientes ( pbcopy < ~/.ssh/id_rsa_work_user1.pub) y repita los pasos anteriores en sus cuentas de trabajo de GitHub.

3. Registro de las nuevas claves SSH con ssh-agent

Para usar las claves, tenemos que registrarlas con el ssh-agent en nuestra máquina. Asegúrese de que ssh-agent se esté ejecutando mediante el comando eval "$(ssh-agent -s)".

Agregue las claves al ssh-agent así:

ssh-add ~/.ssh/id_rsa ssh-add ~/.ssh/id_rsa_work_user1

Haga que el ssh-agent use las respectivas claves SSH para los diferentes hosts SSH.

Esta es la parte crucial y tenemos dos enfoques diferentes:

Usar el archivo de configuración SSH (paso 4) y tener solo una clave SSH activa en el agente ssh a la vez (paso 5).

4. Creación del archivo de configuración SSH

Aquí estamos agregando las reglas de configuración SSH para diferentes hosts, indicando qué archivo de identidad usar para qué dominio.

El archivo de configuración SSH estará disponible en ~ / .ssh / config .Edítelo si existe, o simplemente podemos crearlo.

$ cd ~/.ssh/ $ touch config // Creates the file if not exists $ code config // Opens the file in VS code, use any editor

Realice entradas de configuración para las cuentas de GitHub relevantes similares a la que se muestra a continuación en su ~/.ssh/configarchivo:

# Personal account, - the default config Host github.com HostName github.com User git IdentityFile ~/.ssh/id_rsa # Work account-1 Host github.com-work_user1 HostName github.com User git IdentityFile ~/.ssh/id_rsa_work_user1

" Work_user1 " es el ID de usuario de GitHub para la cuenta de trabajo.

G ithub.com- work_user1 ” es una notación que se usa para diferenciar las múltiples cuentas de Git. También puede utilizar la notaciónwork_user1.g ithub.com” . Asegúrese de ser coherente con la notación de nombre de host que utiliza. Esto es relevante cuando clona un repositorio o cuando establece el origen remoto para un repositorio local.

La configuración anterior le pide a ssh-agent que:

  • Usa id_rsa como claveparacualquier URL de Git que use @ github.com
  • Use la clave id_rsa_work_user1 para cualquier URL de Git que use @ github.com-work_user1

5. Una clave SSH activa en el agente ssh a la vez

Este enfoque no requiere las reglas de configuración SSH. Más bien, nos aseguramos manualmente de que el ssh-agent solo tenga la clave relevante adjunta en el momento de cualquier operación de Git.

ssh-add -lenumerará todas las claves SSH adjuntas al ssh-agent. Elimínelos todos y agregue la clave que está a punto de usar.

Si está a punto de enviar una cuenta personal de Git:

$ ssh-add -D //removes all ssh entries from the ssh-agent $ ssh-add ~/.ssh/id_rsa // Adds the relevant ssh key

El ssh-agent ahora tiene la clave asignada con la cuenta personal de GitHub, y podemos hacer un envío de Git al repositorio personal.

Para enviar a su cuenta de trabajo GitHub-1, cambie la clave SSH asignada con el agente ssh eliminando la clave existente y agregando la clave SSH asignada con la cuenta de trabajo de GitHub.

$ ssh-add -D $ ssh-add ~/.ssh/id_rsa_work_user1

The ssh-agent at present has the key mapped with the work Github account, and you can do a Git push to the work repository. This requires a bit of manual effort, though.

Setting the git remote Url for the local repositories

Once we have local Git repositories cloned /created, ensure the Git config user name and email is exactly what you want. GitHub identifies the author of any commit from the email id attached with the commit description.

To list the config name and email in the local Git directory, do git config user.name and git config user.email. If it’s not found, update accordingly.

git config user.name "User 1" // Updates git config user name git config user.email "[email protected]"

6. While Cloning Repositories

Note: step 7 will help, if we have the repository already available on local.

Now that the configurations are in place, we can go ahead and clone the corresponding repositories. On cloning, make a note that we use the host names that we used in the SSH config.

Repositories can be cloned using the clone command Git provides:

git clone [email protected]:personal_account_name/repo_name.git

The work repository will require a change to be made with this command:

git clone [email protected]_user1:work_user1/repo_name.git

This change is made depending on the host name defined in the SSH config. The string between @ and : should match what we have given in the SSH config file.

7. For Locally Existing Repositories

If we have the repository already cloned:

List the Git remote of the repository, git remote -v

Check whether the URL matches our GitHub host to be used, or else update the remote origin URL.

git remote set-url origin [email protected]_user1:worker_user1/repo_name.git

Ensure the string between @ and : matches the Host we have given in the SSH config.

If you are creating a new repository on local:

Initialize Git in the project folder git init.

Create the new repository in the GitHub account and then add it as the Git remote to the local repository.

git remote add origin [email protected]_user1:work_user1/repo_name.git 

Ensure the string between @ and : matches the Host we have given in the SSH config.

Push the initial commit to the GitHub repository:

git add . git commit -m "Initial commit" git push -u origin master

We are done!

Adding or updating the Git remote of the local Git directory with the proper host will take care of selecting the correct SSH key to verify our identity with GitHub. With all the above in place, our git operations should work seamlessly.