This post details how to go about using more than one GitHub account with SSH.
Quick reference (if you've done this before)
Example GitHub email and username used for the process outlined below, respectively (this guide assumes you are using Bash as your shell):
- GitHub Email:
johndoessh@gmail.com - GitHub Username:
johndoessh
Quick version to copy and past line by line (do not copy and paste all at once; replace JOHNDOESSH as appropriate; step by step version with some commentary follows):
cd ~/.ssh
ssh-keygen -t rsa -b 4096 -C JOHNDOESSH@gmail.com
# id_rsa_JOHNDOESSH # file in which to save the key
# Press Enter # do not associate a passphrase with key
# Press Enter # confirm no associated passphrase with key
eval "$(ssh-agent -s)"
echo -e "# JOHNDOESSH@gmail.com account (GitHub username: JOHNDOESSH)\nHost github-JOHNDOESSH\n\tHostName github.com\n\tUser git\n\tIdentityFile ~/.ssh/id_rsa_JOHNDOESSH" >> ~/.ssh/config
ssh-add -K ~/.ssh/id_rsa_JOHNDOESSH
pbcopy < ~/.ssh/id_rsa_JOHNDOESSH.pub
# https://github.com/settings/keys # <-- Visit this link to add the SSH key to your GitHub account
Now run the following to test your SSH connection:
cd ~/Desktop && mkdir example-repo && cd example-repo && echo "Example repo using SSH" >> README.md
git init
git config user.email "johndoessh@gmail.com"
git add .
git commit -m "initial commit"
git remote add origin
git push -u origin master
Here is the entire process as a short video (open in new tab to see more clearly):
The quick process outlined above is shown below in more detail:
- Navigate to
.sshfolder in home directory:
cd ~/.ssh
You want to be in the ~/.ssh folder for the duration of setting up your SSH connection to your GitHub account.
- Generate SSH key associated with GitHub email:
ssh-keygen -t rsa -b 4096 -C "johndoessh@gmail.com"
Use id_rsa_johndoessh when you encounter the following prompt after executing the line above: Enter a file in which to save the key (/Users/you/.ssh/id_rsa): . Then press Enter twice to avoid setting a passphrase (first to specify no passphrase and then again to confirm no passphrase).
- Start the ssh-agent in the background:
eval "$(ssh-agent -s)"
- Modify
~/.ssh/configfile to automatically load keys into the ssh-agent and store passphrases in keychain:
echo -e '# johndoessh@gmail.com account (GitHub username: johndoessh)\nHost github-johndoessh\n\tHostName github.com\n\tUser git\n\tIdentityFile ~/.ssh/id_rsa_johndoessh' >> ~/.ssh/config
Executing the line above results in the following being written to the ~/.ssh/config file (you can either do this step manually or programmatically as done above, but you must add these details, except the comment of course, to your ~/.ssh/config file):
# johndoessh@gmail.com account (GitHub username: johndoessh)
Host github-johndoessh
HostName github.com
User git
IdentityFile ~/.ssh/id_rsa_johndoessh
- Add SSH private key to ssh-agent and store passphrase in keychain:
ssh-add -K ~/.ssh/id_rsa_johndoessh
- Copy SSH public key to clipboard:
pbcopy < ~/.ssh/id_rsa_johndoessh.pub
| NOTE (local setup complete) |
|---|
| Everything involving the local set up concerning your SSH key to be used with GitHub should be done now. The step below simply involves actually adding your SSH key to your GitHub account. |
- Add the SSH key to your GitHub account: Click "New SSH key", create a descriptive title (whatever you want), paste the copied key from the step above into the "Key" input field, and then click "Add SSH key".
| NOTE (testing remote repo SSH connection) |
|---|
The next few steps are really what it's all about. We will set up a dummy repository locally, example-repo, and we will create in this repository a sample README.md file with Example repo using SSH as its sole content. Then we will create a repository on GitHub called example-repo-using-ssh. Finally, we will test whether or not we can connect the local repo with the remote repo using SSH (we will test this by trying to push from the local repo to the remote repo by means of an SSH connection). |
- Create dummy local repo on desktop with
README.mdfile:
cd ~/Desktop && mkdir example-repo && cd example-repo && echo "Example repo using SSH" >> README.md
- Initialize git repository:
git init
- Configure git repo user email (skip if this is for default GitHub account):
git config user.email "johndoessh@gmail.com"
As detailed later in these notes, you can skip this step if you are setting things up for the default GitHub user.
- Add all changes to staging area:
git add .
- Commit changes:
git commit -m "initial commit"
- Add remote origin (use default SSH code given by GitHub if this is for default GitHub account):
git remote add origin git@github-johndoessh:johndoessh/example-repo-using-ssh.git
On GitHub, the quick setup SSH option, by default, would give you something like git@github.com:johndoessh/example-repo-using-ssh.git. As detailed later in these notes, you can use this default boilerplate code if and only if the johndoessh GitHub account were your default GitHub account. Otherwise, as indicated above, you need to change the github.com part to github-johndoessh. Note that github-johndoessh is the Host we specified in our ~/.ssh/config file previously:
# johndoessh@gmail.com account (GitHub username: johndoessh)
Host github-johndoessh
HostName github.com
User git
IdentityFile ~/.ssh/id_rsa_johndoessh
If johndoessh were our default GitHub user, then we would simply have Host github.com as the top line (this is detailed later in these notes).
- Push to master:
git push -u origin master
This is the ultimate moment of truth. If everything works as expected, then we should see the terminal enumerating, counting, and writing objects along with some other git-specific things. In the end, we should see something like Branch 'master' set up to track remote branch 'master' from 'origin'. and we should be able to hop back to our GitHub repo, refresh the page, and see the minimal contents from README.md printed on the screen.
As noted here, the -u flag in git push -u origin master adds a tracking reference to the upstream server you are pushing to. What is important here is that this lets you do a git pull without supplying any more arguments. For example, once you do a git push -u origin master, you can later call git pull and git will know that you actually meant git pull origin master. Otherwise, you'd have to type in the whole command.
Reference Links
- Simplified walkthrough: Multiple SSH Keys settings for different github accounts
- Switch between user identities in one Git on one computer
- Set local
user.nameanduser.emaildifferent for each repo - Clear git credentials possibly bundled with your git installation
- Remove cached keys with
ssh-add -Dand removeid_rsaandid_rsa.pubfrom~/.ssh - Create
~/.sshfolder if one doesn't already exist withmkdir -p ~/.ssh - GitHub: Generating a new SSH key and adding it to the ssh-agent
- GitHub: Adding a new SSH key to your GitHub account
- Add proper remote origin with
git remote add origin git@<host-in-ssh-config>:<username>/<repo>.git
Pre-Work
Set up global git config file (i.e., ~/.gitconfig)
Make sure you have a .gitconfig file in your Home directory: cd ~ && ls -1a. If you do not see .gitconfig in the listed contents, then simply create one by executing the following: touch .gitconfig. The goal is to configure some settings for git globally and then be able to apply settings locally.
-
Global git settings: Global git settings, found in
~/.gitconfig, will apply to every git repository you create (unless specified otherwise). -
Local git settings: You can override your global git settings on a repository-by-repository basis (i.e., you can override global git repository settings by adding local git repository settings). When you initialize a git repository with
git init, the.gitfolder that is created has the following directory structure (as of Nov 3, 2020):.
├── HEAD
├── config
├── description
├── hooks
│ ├── applypatch-msg.sample
│ ├── commit-msg.sample
│ ├── fsmonitor-watchman.sample
│ ├── post-update.sample
│ ├── pre-applypatch.sample
│ ├── pre-commit.sample
│ ├── pre-push.sample
│ ├── pre-rebase.sample
│ ├── pre-receive.sample
│ ├── prepare-commit-msg.sample
│ └── update.sample
├── info
│ └── exclude
├── objects
│ ├── info
│ └── pack
└── refs
├── heads
└── tagsThe
configfile is what we are interested in. Thisconfigfile is local to the git repository in which it resides. We can specify settings in this.git/configfile that override the default settings applied globally to all git repositories in the~/.gitconfigfile.
Given that we will be setting up multiple GitHub accounts to be used with git on the same computer, it is imperative that the ~/.gitconfig file contain only what is pertinent to what you want to be considered the "default" GitHub user. For example, here is a small snippet from my own ~/.gitconfig:
[user]
email = daniel.w.farlow@gmail.com
name = Daniel Farlow
[core]
editor = nano
excludesfile = /Users/danielfarlow/.gitignore_global
This means that, by default, if we initialize a git repo locally and sync it remotely to a GitHub repo, then commits on GitHub will show up as being authored by the username GitHub has on file associated with daniel.w.farlow@gmail.com, namely farlowd (it also means the nano editor will be the default one for repos and every repo should ignore what is listed in /Users/danielfarlow/.gitignore_global). That is fine if that is the intended behavior, but that will not be the intended behavior in parts of this guide as we are trying to set up multiple GitHub accounts with commits by different authors all managed on the same computer by the same person.
The next note details how to make sure GitHub recognizes what you want (i.e., author of commit message, etc.), how to override global git settings in a local git repository, etc.
Configure the user or author of a specific git repository (i.e., override what is in ~/.gitconfig)
As observed in the previous note, [user] details that appear in the ~/.gitconfig file will apply to every git repository by default, unless specified otherwise. How do you specify otherwise? Every git repository has a config file that is local to that git repository and may be inspected by looking at .git/config (i.e., initializing a git repo within a directory results in a .git folder being added to that directory and the config file is located within the .git folder).
As noted in this answer, you can set the [user] name and email as desired on a global or local basis:
-
globally (this programmatically updates/writes to
~/.gitconfig):git config --global user.name "My Global Name"
git config --global user.email global@email.comNote that the above is effectively the same as opening
~/.gitconfigand writing the following manually and then saving:[user]
name = My Global Name
email = global@email.com -
locally (this programmatically updates/writes to
.git/configin a git repository):git config user.name "My Local Name"
git config user.email local@email.comNote that the above is effectively the same as opening
.git/configin a local repository and writing the following manually and then saving:[user]
name = My Local Name
email = local@email.com
As a commentor notes, you can check what your current settings are without looking at .git/config directly by omitting the last part: git config user.email or git config user.name.
Why all the fuss? Because if you want commits to show up on GitHub as being authored by different users instead of just your single default user, then you will need to set user.email locally using git config user.email in whatever repository is not being authored by the default user. GitHub identifies the author of the commit and displays this author based on what email is used.
Remove git credentials from keychain
As this answer on Stack Overflow notes, how you installed git may result in the install caching your git credentials in your keychain. You can start by removing this potential source of issues.
Start keychain access (start spotlight via cmd + space, type keychain, press enter). Under keychains on the upper left, select "login" Under category on the left, select "passwords". Find the name "github" and delete it.
As the answer immediately below this one notes, GitHub identifies you by the SSH key it sees, not by any setting from git (more on this soon). For now, as noted in the answer, you can use ssh-add -l to determine which keys are in your keyring, and ssh-add -d <keyfile> to remove a key from your keyring, if it doesn't work remove the 'unwanted' ssh key from ~/.ssh/config.
Given the above, and as we will see later, simply run ssh-add -D to delete all cached keys before embarking on the rest of this journey.
Make sure you have an .ssh folder to store your SSH keys in
Make sure you have an .ssh folder in your home directory (~) in which to store your keys; for example, try cd ~/.ssh. If this fails, then you likely do not have an .ssh folder yet and that is fine. As this answer notes, if you have never generated any SSH keys, or you have not used SSH yet, then the .ssh folder does not need to exist. Since the goal now is to use SSH with GitHub, we will need this folder to exist. Run the following if you do not have an .ssh folder: mkdir -p ~/.ssh.
Make sure you have a config file in your .ssh folder
Assuming you have an .ssh folder, navigate to it and see if you have a config file present: cd ~/.ssh && ls -al. If no config file appears, then you will need to create it: touch ~/.ssh/config.
We will return to the config file before long to configure how we want SSH to work with our separate GitHub accounts.
Instructions
Set up first GitHub accounts
Set up your GitHub accounts. For this write-up, the following was used for the first account:
- GitHub username:
multipleaccounts1 - GitHub email:
tylerhansbrough@gmail.com
And the following was used for the second account (make sure to verify your email for both).
- GitHub username:
multipleaccounts2 - GitHub email:
tylerhansbrough50@gmail.com
Generate SSH keys and add them to the ssh-agent for both accounts
NOTE: Be sure to first read the note above about configuring the user or author of a specific git repository. That note explains why git config user.email is used in some of the instructions that appear below.
We will now follow the GitHub docs to generate and store our SSH keys as well as how we configure our settings. Do the following while inside the ~/.ssh folder (use Bash as your shell):
Example 1
ssh-keygen -t rsa -b 4096 -C "tylerhansbrough@gmail.com"-
When prompted to enter a file in which to save the key, type the following:
id_rsa_th -
When prompted for the passphrase, simply hit Enter twice
-
Run the following after receiving notification of your id and public key being saved:
eval "$(ssh-agent -s)" -
Add the following to the
configfile in your~/.sshfolder:# tylerhansbrough@gmail.com account (GitHub username: multipleaccounts1)
Host github-th
HostName github.com
User git
IdentityFile ~/.ssh/id_rsa_th -
Run the following:
ssh-add -K ~/.ssh/id_rsa_th -
Add the SSH key to your GitHub account by doing the following:
- Go to your profile settings (click on your profile picture and navigate to settings), click the "SSH and GPG keys" in the menu, and click "New SSH key" or "Add SSH key". In the "Title" field, add a descriptive label for the new key. For example, if you're using a personal Mac, you might call this key "Personal MacBook Air". To paste your key into the "Key" field, go back to your terminal and run the following (this copies the contents of the
id_rsa_th.pubfile to your clipboard):pbcopy < ~/.ssh/id_rsa_th.pub. Paste this into the "Key" field and then click "Add SSH key" (confirm your GitHub password, if needed).
- Go to your profile settings (click on your profile picture and navigate to settings), click the "SSH and GPG keys" in the menu, and click "New SSH key" or "Add SSH key". In the "Title" field, add a descriptive label for the new key. For example, if you're using a personal Mac, you might call this key "Personal MacBook Air". To paste your key into the "Key" field, go back to your terminal and run the following (this copies the contents of the
-
To test all of the above out, first go to your GitHub account and create a new repository called examplerepo1. For the quick setup screen that immediately follows, click "SSH" instead of "HTTPS", and you will be greeted by something like git@github.com:multipleaccounts1/examplerepo1.git. But recall the config file:
# tylerhansbrough@gmail.com account (GitHub username: multipleaccounts1)
Host github-th
HostName github.com
User git
IdentityFile ~/.ssh/id_rsa_th
As noted here we need to add something like
git remote add origin git@<host-in-ssh-config>:<username>/<repo>.git
instead of doing something like git remote add origin git@github.com:multipleaccounts1/examplerepo1.git, where this is effectively the same as editing your .git/config file (in the link above, git remote set-url was used instead of git remote add and this was to modify an already existing git repo synced with GitHub instead of adding one). So run the following when appropriate (detailed momentarily--you have to initialize a git repo first):
git remote add origin git@github-th:multipleaccounts1/examplerepo1.git
To see everything come together now, run the following in order:
cd ~/Desktop/
mkdir firstexamplerepo
cd firstexamplerepo
touch README.md
echo "thgithub" >> README.md
git init
git config user.email "tylerhansbrough@gmail.com"
git add .
git commit -m "initial commit"
# instead of the normal: git remote add origin git@github.com:multipleaccounts1/examplerepo1.git
git remote add origin git@github-th:multipleaccounts1/examplerepo1.git
git push -u origin master
Example 2
ssh-keygen -t rsa -b 4096 -C "tylerhansbrough50@gmail.com"-
When prompted to enter a file in which to save the key, type the following:
id_rsa_th50 -
When prompted for the passphrase, simply hit Enter twice
-
Run the following after receiving notification of your id and public key being saved (use
bashinstead of something likefishfor your shell):eval "$(ssh-agent -s)" -
Add the following to the
configfile in your.sshfolder:# tylerhansbrough50@gmail.com account (GitHub username: multipleaccounts2)
Host github-th50
HostName github.com
User git
IdentityFile ~/.ssh/id_rsa_th50 -
Run the following:
ssh-add -K ~/.ssh/id_rsa_th50 -
Add the SSH key to your GitHub account by doing the following:
- Go to your profile settings (click on your profile picture and navigate to settings), click the "SSH and GPG keys" in the menu, and click "New SSH key" or "Add SSH key". In the "Title" field, add a descriptive label for the new key. For example, if you're using a personal Mac, you might call this key "Personal MacBook Air". To paste your key into the "Key" field, go back to your terminal and run the following (this copies the contents of the
id_rsa_th.pubfile to your clipboard):pbcopy < ~/.ssh/id_rsa_th50.pub. Paste this into the "Key" field and then click "Add SSH key" (confirm your GitHub password, if needed).
- Go to your profile settings (click on your profile picture and navigate to settings), click the "SSH and GPG keys" in the menu, and click "New SSH key" or "Add SSH key". In the "Title" field, add a descriptive label for the new key. For example, if you're using a personal Mac, you might call this key "Personal MacBook Air". To paste your key into the "Key" field, go back to your terminal and run the following (this copies the contents of the
-
To test all of the above out, first go to your GitHub account and create a new repository called examplerepo2. For the quick setup screen that immediately follows, click "SSH" instead of "HTTPS", and you will be greeted by something like git@github.com:multipleaccounts2/examplerepo2.git. But recall the config file:
# tylerhansbrough50@gmail.com account (GitHub username: multipleaccounts2)
Host github-th50
HostName github.com
User git
IdentityFile ~/.ssh/id_rsa_th50
As noted here we need to add something like
git remote add origin git@<host-in-ssh-config>:<username>/<repo>.git
instead of doing something like git remote add origin git@github.com:multipleaccounts2/examplerepo2.git, where this is effectively the same as editing your .git/config file (in the link, set-url was used instead of add and this was to modify an already existing git repo synced with GitHub instead of adding one). So run the following when appropriate (detailed momentarily--you have to initialize a git repo first):
git remote add origin git@github-th50:multipleaccounts2/examplerepo2.git
To see everything come together now, run the following in order:
cd ~/Desktop/
mkdir secondexamplerepo
cd secondexamplerepo
touch README.md
echo "th50github" >> README.md
git init
git config user.email "tylerhansbrough50@gmail.com"
git add .
git commit -m "initial commit"
# instead of the normal: git remote add origin git@github.com:multipleaccounts2/examplerepo2.git
git remote add origin git@github-th50:multipleaccounts2/examplerepo2.git
git push -u origin master
Follow Up
Ensuring you can still push to old repositories you had synced between git and GitHub
It's easy to forget the importance of, or be completely unaware of, the .git/config file in all repositories where you have previously set up git and remotely synced it with one of your repositories on GitHub. To make sure you can still push to such repositories, make sure you inspect your .git/config file and compare it with your config file in your .ssh folder.
For example, I originally had
[remote "origin"]
url = git@github.com:daniel-farlow/just-express.git
in the .git/config folder of my just-express directory, but I added another GitHub account to be used as my primary one and I now had the following in ~/.ssh/config after reconfiguring things:
#daniel-farlow account
Host github-daniel-farlow
HostName github.com
User git
IdentityFile ~/.ssh/id_rsa_daniel-farlow
When I tried to push to sync everything on GitHub with what was in my local repository, I encountered an "access denied" error. Why? The reason was due to my new configuration. What was previously
[remote "origin"]
url = git@github.com:daniel-farlow/just-express.git
in .git/config needed to now become
[remote "origin"]
url = git@github-daniel-farlow:daniel-farlow/just-express.git
Specifically, note how github.com (the host) changed to github-daniel-farlow and how this reflects what is in the ~/.ssh/config file.
Hence, if you have changed your configuration, then you may need to go back through several repositories to update the remote origin as detailed above. You can do this via git remote set-url ... as opposed to editing the .git/config file directly (the .git/config file is what is changed in both cases; git remote set-url ... simply writes to this file).
Whatever the case, you need to make sure you are effectively syncing your remote GitHub repository with your local git repository. The next note details how to do this on a consistent basis.
Being consistent and careful when you use SSH to sync your GitHub repo with your local git repo
As noted previously, when creating a repository on GitHub, the quick setup offers you an SSH option:
git@github.com:<username-of-github-account>/<repository-name>.git
When you change your SSH config in ~/.ssh/config you need to be somewhat careful here. For example, consider the following ~/.ssh/config:
# tylerhansbrough@gmail.com account (GitHub username: multipleaccounts1)
Host github-th
HostName github.com
User git
IdentityFile ~/.ssh/id_rsa_th
# tylerhansbrough50@gmail.com account (GitHub username: multipleaccounts2)
Host github-th50
HostName github.com
User git
IdentityFile ~/.ssh/id_rsa_th50
If we are using our GitHub account with username multipleaccounts1 and we have just created the GitHub repository becareful, then instead of using the default SSH option that GitHub gives us
git@github.com:multipleaccounts1/becareful.git
by doing
git remote add origin git@github.com:multipleaccounts1/becareful.git
we should INSTEAD do the following in our local git repository:
git remote add origin git@github-th:multipleaccounts1/becareful.git
Then we should be able to push now. With all of the above said, it is worth mentioning that you may want to have what you consider your default GitHub account detailed in your ~/.ssh/config (modifying the SSH option every single time you create a GitHub repository, as detailed in the previous note, can get rather cumbersome). Head to the next note for details on setting up a sort of "default user".
Setting a "default" GitHub user
In many ways, this answer on Stack Overflow details all that is necessary, but we will repurpose the answer to mesh well with the examples we have used so far. As the linked to answer notes, the crucial part in setting up a sort of "default" GitHub user is to use a different ssh psuedo-host for each account with github.com being assigned to what we want to consider the "default" GitHub account.
For example, suppose we want our GitHub account with username multipleaccounts1 to be the "default" account. Before changing the ssh psuedo-host, we should globally change the [user] email as observed in an earlier note about configuring the user or author for a local git repository:
# git config --global user.name "Some Name" # IF YOU WANT TO UPDATE THE DEFAULT NAME
git config --global user.email "tylerhansbrough@gmail.com"
Now we simply need to change the ssh psuedo-host for multipleaccounts1 from github-th to github.com. That is, in ~/.ssh/config, we need to change
# tylerhansbrough@gmail.com account (GitHub username: multipleaccounts1)
Host github-th
HostName github.com
User git
IdentityFile ~/.ssh/id_rsa_th
to
# tylerhansbrough@gmail.com account (GitHub username: multipleaccounts1)
Host github.com
HostName github.com
User git
IdentityFile ~/.ssh/id_rsa_th
Let's see what this does. On GitHub, while using the account with username multipleaccounts1, create a repository titled becareful. The SSH option given by GitHub is as follows:
git@github.com:multipleaccounts1/becareful.git
The upshot of all this is that we do not have to change this now and we also do not have to use git config user.email "tylerhansbrough@gmail.com". That is, instead of sequentially running
cd ~/Desktop/
mkdir becareful
cd becareful
touch README.md
echo "thbecareful" >> README.md
git init
git config user.email "tylerhansbrough@gmail.com" # KEEP EYES ON THIS
git add .
git commit -m "initial commit"
git remote add origin git@github-th:multipleaccounts1/becareful.git # KEEP EYES ON THIS TOO
git push -u origin master
we can instead run
cd ~/Desktop/
mkdir becareful
cd becareful
touch README.md
echo "thbecareful" >> README.md
git init
git add .
git commit -m "initial commit"
git remote add origin git@github.com:multipleaccounts1/becareful.git # DID NOT HAVE TO CHANGE WHAT GITHUB GAVE US!
git push -u origin master
Notice how we did not have to use git config user.email "tylerhansbrough@gmail.com" at all and we also did not have to change the boilerplate SSH code that GitHub gave us when setting up the repository. Quite convenient! Of course, if we wanted to use the GitHub account with username multipleaccounts2 instead, then we would need to change
git@github.com:multipleaccounts2/becareful.git
to
git@github-th50:multipleaccounts2/becareful.git
as well as add git config user.email "tylerhansbrough50@gmail.com".
One slightly subtle thing to remember is how your configuration changes propagate to not only pushing but also pulling, cloning, etc. That is why, in the model answer, with ~/.ssh/config as
# Default GitHub user (joe)
Host github.com
HostName github.com
User git
IdentityFile /Users/joe/.ssh/id_rsa
# Client user (client)
Host github-client
HostName github.com
User git
IdentityFile /Users/joe/.ssh/id_rsa_client
we are told that we then have two corresponding remotes:
git clone git@github.com:joe/my_repo.git
and
git clone git@github-client:client/his_repo.git
Hence, using our example, if you want to clone the linux repo on GitHub using your multipleaccounts1 GitHub account, then all you have to do now is simply execute the following:
git clone git@github.com:torvalds/linux.git
But if you want to clone the linux repository using your multipleaccounts2 GitHub account, then you will need to execute the following instead:
git clone git@github-th50:torvalds/linux.git
As the model answer concludes, you can specify different emails and other user details (and more than just user details) by editing the [user] settings in .git/config.
My current ~/.ssh/config file
As of right now, I have the following in my ~/.ssh/config file:
IPQoS=throughput
# daniel.w.farlow@gmail.com account (GitHub username: dfarlow)
Host github.com
HostName github.com
User git
IdentityFile ~/.ssh/id_rsa_dfarlow
# dan.farlow@gmail.com account (GitHub username: daniel-farlow)
Host github-daniel-farlow
HostName github.com
User git
IdentityFile ~/.ssh/id_rsa_daniel-farlow
# tylerhansbrough@gmail.com account (GitHub username: multipleaccounts1)
Host github-th
HostName github.com
User git
IdentityFile ~/.ssh/id_rsa_th
# tylerhansbrough50@gmail.com account (GitHub username: multipleaccounts2)
Host github-th50
HostName github.com
User git
IdentityFile ~/.ssh/id_rsa_th50
I also have the following in my ~/.gitconfig file:
[user]
email = daniel.w.farlow@gmail.com
name = Daniel Farlow
[core]
editor = nano
excludesfile = /Users/danielfarlow/.gitignore_global
The result is that my GitHub account with email daniel.w.farlow@gmail.com (and username dfarlow on GitHub) is my "default" GitHub account. If I want to have commits on GitHub show up as coming from the following authors, then I need to take the following actions:
-
dfarlow: This is the username associated with
daniel.w.farlow@gmail.comon GitHub and since[user]
email = daniel.w.farlow@gmail.com
name = Daniel Farlowis in my
~/.gitconfigfile, every git repository I initialize on my computer will, by default (and hence the idea of a "default" GitHub account), havedfarlowas the author (i.e., the GitHub username associated with the[user]email in my~/.gitconfigfile) for commits and other things on GitHub. -
daniel-farlow: This is the username associated with
dan.farlow@gmail.comon GitHub, anddan.farlow@gmail.comdoes not show up as the[user]email in my~/.gitconfigfile; thus, in order for commits and other such actions on GitHub to show up as having come fromdaniel-farlow, the following will need to be run after executinggit initin a local repository (or at another time of choosing):git config user.email = "dan.farlow@gmail.com"This will ensure actions on GitHub are associated with author/username
daniel-farlowwhich is linked todan.farlow@gmail.comon GitHub. -
multipleaccounts1: This is the username associated with
tylerhansbrough@gmail.comon GitHub, andtylerhansbrough@gmail.comdoes not show up as the[user]email in my~/.gitconfigfile; thus, in order for commits and other such actions on GitHub to show up as having come frommultipleaccounts1, the following will need to be run after executinggit initin a local repository (or at another time of choosing):git config user.email = "tylerhansbrough@gmail.com"This will ensure actions on GitHub are associated with author/username
multipleaccounts1which is linked totylerhansbrough@gmail.comon GitHub. -
multipleaccounts2: This is the username associated with
tylerhansbrough50@gmail.comon GitHub, andtylerhansbrough50@gmail.comdoes not show up as the[user]email in my~/.gitconfigfile; thus, in order for commits and other such actions on GitHub to show up as having come frommultipleaccounts2, the following will need to be run after executinggit initin a local repository (or at another time of choosing):git config user.email = "tylerhansbrough50@gmail.com"This will ensure actions on GitHub are associated with author/username
multipleaccounts2which is linked totylerhansbrough50@gmail.comon GitHub.