Comment gérer plusieurs comptes GitHub sur une seule machine avec des clés SSH

La nécessité de gérer plusieurs comptes GitHub sur la même machine survient à un moment donné pour la plupart des développeurs. Chaque fois que je change de Mac ou que j'ai besoin de Git push avec un nouveau compte professionnel, je finis par surfer pour savoir comment faire quelque chose que j'ai fait plus d'une demi-douzaine de fois.

Ma paresse à ne pas documenter le processus et mon incapacité à me souvenir des étapes me font passer un temps décent à récupérer les éléments de partout sur le Web, puis à les faire fonctionner.

Je suis sûr que vous êtes nombreux à avoir été là-bas, à faire cela et à bien d'autres qui attendent juste la prochaine fois que la même chose se produira (moi y compris!). Cet effort est destiné à nous aider tous.

1. Génération des clés SSH

Avant de générer une clé SSH, nous pouvons vérifier si nous avons des clés SSH existantes: ls -al ~/.sshcela listera toutes les paires de clés publiques et privées existantes, le cas échéant.

S'il ~/.ssh/id_rsaest disponible, nous pouvons le réutiliser, ou bien nous pouvons d'abord générer une clé ~/.ssh/id_rsapar défaut en exécutant:

ssh-keygen -t rsa

Lorsqu'on vous demande l'emplacement pour enregistrer les clés, acceptez l'emplacement par défaut en appuyant sur Entrée. Une clé privée et une clé publique ~/.ssh/id_rsa.pubseront créées à l'emplacement ssh par défaut ~/.ssh/.

Utilisons cette paire de clés par défaut pour notre compte personnel.

Pour les comptes professionnels, nous créerons différentes clés SSH. Le code ci-dessous générera les clés SSH et enregistre la clé publique avec la balise "[email protected]_mail.com" dans~/.ssh/id_rsa_work_user1.pub

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

Nous avons créé deux clés différentes:

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

2. Ajout de la nouvelle clé SSH au compte GitHub correspondant

Nous avons déjà les clés publiques SSH prêtes et nous demanderons à nos comptes GitHub de faire confiance aux clés que nous avons créées. C'est pour vous débarrasser de la nécessité de taper le nom d'utilisateur et le mot de passe chaque fois que vous effectuez un push Git.

Copiez la clé publique pbcopy < ~/.ssh/id_rsa.pub, puis connectez-vous à votre compte GitHub personnel:

  1. Aller à Settings
  2. Sélectionnez SSH and GPG keysdans le menu de gauche.
  3. Cliquez sur New SSH key, fournissez un titre approprié et collez la clé dans la case ci-dessous
  4. Cliquez Add key- et vous avez terminé!
Pour les comptes professionnels, utilisez les clés publiques correspondantes ( pbcopy < ~/.ssh/id_rsa_work_user1.pub) et répétez les étapes ci-dessus dans vos comptes professionnels GitHub.

3. Enregistrement des nouvelles clés SSH avec l'agent ssh

Pour utiliser les clés, nous devons les enregistrer avec l' agent ssh sur notre machine. Assurez-vous que ssh-agent est en cours d'exécution à l'aide de la commande eval "$(ssh-agent -s)".

Ajoutez les clés à l'agent ssh comme ceci:

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

Faites en sorte que l'agent ssh utilise les clés SSH respectives pour les différents hôtes SSH.

C'est la partie cruciale, et nous avons deux approches différentes:

Utilisation du fichier de configuration SSH (étape 4) et avoir une seule clé SSH active dans l'agent ssh à la fois (étape 5).

4. Création du fichier de configuration SSH

Ici, nous ajoutons en fait les règles de configuration SSH pour différents hôtes, indiquant quel fichier d'identité utiliser pour quel domaine.

Le fichier de configuration SSH sera disponible dans ~ / .ssh / config .Modifiez-le s'il existe, sinon nous pouvons simplement le créer.

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

Effectuez des entrées de configuration pour les comptes GitHub pertinents similaires à celle ci-dessous dans votre ~/.ssh/configfichier:

# 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 » est l'ID utilisateur GitHub du compte professionnel.

« G ithub.com- work_user1 » est une notation utilisée pour différencier les multiples comptes Git. Vous pouvez également utiliser la notation « work_user1.g ithub.com» . Assurez-vous que vous êtes cohérent avec la notation de nom d'hôte que vous utilisez. Ceci est pertinent lorsque vous clonez un référentiel ou lorsque vous définissez l'origine distante pour un référentiel local

La configuration ci-dessus demande à ssh-agent de:

  • Utilisez id_rsa comme clépourtoute URL Git qui utilise @ github.com
  • Utilisez la clé id_rsa_work_user1 pour toute URL Git qui utilise @ github.com-work_user1

5. Une clé SSH active dans l'agent ssh à la fois

Cette approche ne nécessite pas les règles de configuration SSH. Nous nous assurons plutôt manuellement que l'agent ssh n'a que la clé appropriée attachée au moment de toute opération Git.

ssh-add -llistera toutes les clés SSH attachées à l'agent ssh. Supprimez-les tous et ajoutez la clé que vous êtes sur le point d'utiliser.

Si c'est sur un compte Git personnel que vous êtes sur le point de pousser:

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

L'agent ssh a maintenant la clé mappée avec le compte GitHub personnel, et nous pouvons faire un push Git vers le référentiel personnel.

Pour pousser vers votre compte GitHub professionnel-1, modifiez la clé SSH mappée avec l'agent ssh en supprimant la clé existante et en ajoutant la clé SSH mappée avec le compte professionnel 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.