DEV Community

Cover image for How to manage multiple GitHub accounts on your local machine
Lars
Lars

Posted on • Originally published at blog.larsbehrenberg.com

How to manage multiple GitHub accounts on your local machine

*This post was first published on my blog.

One issue that I have run into multiple times in the past is how to manage multiple GitHub accounts on my local machine. Whether you are working on git repositories from multiple clients or you are switching back and forth between personal and the company accounts, almost every developer will eventually encounter this problem. Also for me, I end up looking it up every time I set up a new machine 🀐

So here is a quick reminder of how to go about this, because it does need a little setup to work nicely.

Table Of Contents

Getting Started

Use SSH instead of HTTPS

To set up different accounts on your local machine, we will be using SSH keys instead of the usual HTTPS connection. This has its advantages and disadvantages, and GitHub occasionally changes its opinion on what it recommends best, but here is a quote from the GitHub docs on why we will use SSH keys in this case.

Using the SSH protocol, you can connect and authenticate to remote servers and services. With SSH keys, you can connect to GitHub without supplying your username and personal access token at each visit.

  • Github | About SSH

Perfect for us. We don't want to reauthenticate every time and instead commit changes to our repositories as if we never switched accounts. But how do we set that up?

A quick note here: if you would like to learn more about the differences between HTTPS and SSH, there is an extensive write-up in the GitHub docs! **It's worth checking out!**

Understand the structure of SSH on your local machine

To put it simply: the way this will work is to create unique keys (SSH keys) on your local machine that we will then add to your Github accounts. GitHub won't have to look up your login credentials every time then and instead can verify you by your SSH key. Sound pretty good, right?

But where do the keys get stored on your local machine?

In a folder called ~/.ssh. This is where our setup will happen. Instead of having to set up configuration every time we clone from one of our accounts, once we have made our SSH setup in this folder, we just clone and commit to repositories from different accounts without ever thinking about having to switch accounts on your local machine!

Let's get started!

Set up your local SSH config

If you were to look for your ~/.ssh folder, you might notice that it doesn't exist yet, if for example you never created any keys previously. But instead of creating the folder now ourselves, let our machine do that for us. We start by creating our first key.

Generate SSH keys

When we create SSH keys on our machine, it automatically generates some files and configurations for us. In this tutorial, we will assume you haven't set up any SSH keys yet.

We get started with the command that will generate the first key:

ssh-keygen -t rsa
Enter fullscreen mode Exit fullscreen mode

You will be prompted and asked to enter the folder/file name you want to go with. Press ENTER to go with the default location and generate the ~/.ssh folder.

Enter custom file name

You now have a ~/.ssh folder, with the just created SSH key. Let's use this default key for our personal account.

Next up is creating a key for our work account. (You can repeat this process for as many keys as necessary) And for this we will have to specify the key with some flags. "-C" adds a comment/tag and -f specifies the name of the file we want to save the key to.

Go into your ~/.ssh folder:

cd ~/.ssh
Enter fullscreen mode Exit fullscreen mode

And create your next key with custom flags.

ssh-keygen -t rsa -C "email@githubworkemail.com" -f "id_rsa_workname"
Enter fullscreen mode Exit fullscreen mode

To dive deeper, here is a list of the different flags you can add:

List of flags for SSH-keygen

To double-check that all of your keys are there, type:

ls ~/.ssh
Enter fullscreen mode Exit fullscreen mode

Create a config to manage multiple keys

Now that we have created our keys, we need a configuration file that knows which key to use when we access a repo of one of our GitHub accounts.

For this inside our ~/.ssh folder, we create and open a config file.

touch ~/.ssh/config && code ~/.ssh/config
Enter fullscreen mode Exit fullscreen mode

In here we define our different accounts:

# personal account
Host github.com
   HostName github.com
   User git
   IdentityFile ~/.ssh/id_rsa

# work account 1
Host github.com-workname
   HostName github.com
   User git
   IdentityFile ~/.ssh/id_rsa_workname
Enter fullscreen mode Exit fullscreen mode

Two things are important to note here:

The host, which we will need to remember later when we get our SSH links from GitHub.

Host github.com-workname
Enter fullscreen mode Exit fullscreen mode

and the identity file, to make sure it points to the correct SSH key that we created before.

IdentityFile ~/.ssh/id_rsa_workname
Enter fullscreen mode Exit fullscreen mode

Register our ssh-agent

Now to keep track of our different SSH keys and their configurations, there is a service called "ssh-agent". It is essentially the key manager for SSH.

For our purposes, we need to know 3 different commands.

ssh-add -D              // removes all currently registered ssh keys from the ssh-agent
ssh-add -l              // lists all currently in the ssh-agent registered ssh keys
ssh-add ~/.ssh/id_rsa   // adds the specified key to the ssh-agent
Enter fullscreen mode Exit fullscreen mode

If you haven't configured any keys previously your ssh-agent has most likely not registered any keys, but let's be completely sure and run:

ssh-add -D              // removes all currently registered ssh keys from the ssh-agent
Enter fullscreen mode Exit fullscreen mode

Next up is registering our keys with their ids:

ssh-add ~/.ssh/id_rsa && ssh-add ~/.ssh/id_rsa_workname
Enter fullscreen mode Exit fullscreen mode

Done! With this, our local machine is set up and all that is left to do is to register our keys in GitHub and clone our first repo!

Add the SSH keys to your GitHub accounts

There are two steps to this. First, copy the correct key and second, add the key in your dashboard on GitHub.

  1. Copying the correct key.

    pbcopy < ~/.ssh/id_rsa.pub
    

    This will copy your public key to your clipboard

  2. Add the key in your dashboard at https://github.com/settings/keys.

GitHub add a SSH key

Login into your work GitHub account and repeat this process with your work SSH key.

Clone your repo

Important to note!
The reason why your computer knows which SSH key to use, is because we defined the URL in our config file.

This means that for our work repositories, when we clone a repo from the account, like so:

Choose SSH link in GitHub

We have to change the URL from:

git@github.com:workname/repo.git β‡’ git@github.com-workname:workname/repo.git

The same URL we have previously defined in our ~/.ssh/config file.

**Host github.com-workname  // HERE**
   HostName github.com
   User git
   IdentityFile ~/.ssh/id_rsa_workname
Enter fullscreen mode Exit fullscreen mode

With this, you can now clone your repositories and get going! Back to coding, I'd say!

That’s it!

Thanks so much for reading this far and feel free to reach out to me anytime, on my website or on Twitter πŸ™‚

Top comments (8)

Collapse
 
jonrandy profile image
Jon Randy πŸŽ–οΈ

Alternatively, use a GUI client that handles it for you :)

Collapse
 
omanfk profile image
O.F.K.

Sorry for being late to the party, but just want to put in my two cents that the problem with using a GUI app to handle it for you is... that you're using a GUI app to handle it for you, meaning you're locked-in to that one app.

By configuring your keys like in the article you can use the CLI, the built-in Git tools bundled with your IDE of choice, or even your favorite UI app.
Your call.
No more need to switch applications, and contexts, every time you need to perform a Git-related action.

This freedom is priceless when you're Git-intensive, and just best practices all around.

Collapse
 
codetraveling profile image
Lars

Which one do you recommend? :)

Collapse
 
jonrandy profile image
Jon Randy πŸŽ–οΈ

Personally, I use GitKraken. Handles multiple accounts really well

Thread Thread
 
indigowizard profile image
IndigoWizard

True, GitKraken offers a quick and easy setup and handles pretty well multiple accounts.

Collapse
 
c_v_ya profile image
Constantine

Been using ssh config since forever, but it always been with different hosts. And just now figured how to manage multiple users via -workname on the same host. Thanks!

Collapse
 
rahxuls profile image
Rahul

Amazing and needy post

Collapse
 
codetraveling profile image
Lars

Thanks a lot!