Reputation: 13435

Multiple GitHub accounts on the same computer?

Trying to work on both my actual "work" repos, and my repos on GitHub, from my computer.

The work account was set up first, and everything works flawlessly.

My account, however, cannot seem to push to my repo, which is set up under a different account/email.

I've tried copying my work key up to my account, but that throws an error because of course a key can only be attached to one account.

How can I push/pull to and from both accounts with their respective GitHub credentials?

Upvotes: 838

Answers (30)

v.v

Reputation: 47

Here's "rough" trick working for technical pulls / pushes.
Barely can be used for common workflows.

Having accounts with PATs:

Repo github.com/foo/project-A: username foo, PAT XXX
Repo github.com/bar/project-B: username bar, PAT YYY

You create directories with .netrc files for each repo, for example:

# cat ~/.a/.netrc
machine github.com login foo password XXX

# cat ~/.b/.netrc
machine github.com login bar password YYY

And then fake HOME for git calls implying data transfer (clone, pull, push etc):

# HOME=~/.a git clone github.com/foo/project-A

Upvotes: 0

Bheru Lal Lohar

Reputation: 1060

Update : July 2024

GitHub CLI now support multiple accounts -

Add accounts using:

gh auth login

and switch between accounts using:

gh auth switch

Upvotes: 0

Aniket K

Reputation: 434

Generate a Personal Access Token

Go to your GitHub account settings.
In the left sidebar, click on "Developer settings."
Click on "Personal access tokens."
Click on "Generate new token."
Give your token a descriptive name, select the scopes or permissions you'd like to grant this token, and then click "Generate token."
Important: Copy your new personal access token. You won’t be able to see it again!

Clone the Repository

Open Terminal on your Mac.
Use the git clone command with the repository URL and your personal access token. Replace <repository-url> with the URL of the repository and <your-token> with your personal access token.
```
git clone https://<your-token>@github.com/username/repository.git
```
This will clone the repository using your personal access token for authentication.

Configure Git User

Use the cd command to navigate to the directory of the cloned repository.
```
cd <repository-name>
```
If you haven't already, configure your Git user information for the current repository. This is important to ensure that your commits are associated with the correct user.
```
git config user.email "your-email@example.com"
git config user.name "Your Name"
```

Authenticate Git:

When you perform operations like pushing or pulling to/from the repository, Git will prompt you for your GitHub username (your email address associated with the account) and your personal access token as the password.

By following these steps, you should be able to clone a private repository from a different GitHub account and work with it on your Mac without disturbing your other GitHub account.

Upvotes: 0

pvrforpranavvr

Reputation: 2948

Generate ssh keys
```
ssh-keygen -t ed25519 -C "your_email"
```
Copy the public key from .ssh folder and add to your git-repository account
Go to ~/.ssh
Create a file named config(have no extension )
Open config file & add below codes. (change according to your account)

Account 1

    # account_1
    Host gitlab.com-account_1
    HostName gitlab.com
    User git
    PreferredAuthentications publickey
    IdentityFile ~/.ssh/id_rsa_account_1

Account 2

    # Account2
    Host gitlab.com-Account2
    HostName gitlab.com
    User git
    PreferredAuthentications publickey
    IdentityFile ~/.ssh/id_rsa_Account2

Account 3

    # Account_3
    Host github.com-Account3
    HostName github.com
    User git
    PreferredAuthentications publickey
    IdentityFile ~/.ssh/id_rsa_Account_3

Add remote url as follows

Account 1

     git remote add origin git@gitlab.com-account_1:group_name/repo_name.git

Account 2

     git remote add origin git@gitlab.com-Account2:group_name/repo_name.git

Account 3

     git remote add origin github.com-Account3:github_username/repo_name.git

Make sure that IdentityFile names are same as you created during ssh key generation.

Upvotes: 23

Mohanraj Karatadipalayam

Reputation: 777

For MacOS - Using gh CLI

Install gh CLI

 brew install gh

For MacOS, you don't need to run git config because GCM automatically configures Git for you.

When you need to switch the accounts you login

gh auth login

it will ask something similar to below

? What account do you want to log into? GitHub Enterprise Server
? GHE hostname: github.com
? You're already logged into github.com. Do you want to re-authenticate? Yes
? What is your preferred protocol for Git operations? HTTPS
? Authenticate Git with your GitHub credentials? Yes
? How would you like to authenticate GitHub CLI? Login with a web browser

! First copy your one-time code: XXXX-XXXX
Press Enter to open github.com in your browser...
✓ Authentication complete.
- gh config set -h github.com git_protocol https
✓ Configured git protocol
✓ Logged in as xxxx_xxxx

and then you clone / or do any other git operations as below

gh repo clone project/repo

Refer: https://docs.github.com/en/get-started/getting-started-with-git/caching-your-github-credentials-in-git

Upvotes: 0

Greg Leszek

Reputation: 3818

Use HTTPS

change remote url to https:

git remote set-url origin https://USERNAME@github.com/USERNAME/PROJECTNAME.git

and you are good to go:

git push

When you first enter your password, you will probably see this message:

Support for password authentication was removed on August 13, 2021.

You must use a Github PAT to do HTTPS pushes on github.com

Your PAT will look like a 40 character letter/number hash, like

zIa03uTnN0TTaReAALT09K33NMBbCfum6lw8TDSb

When you push using this method, you will be presented with a dialog box when you push:

Github enter password PAT dialog on Windows 10

To ensure that the commits appear as performed by USERNAME, one can setup the user.name and user.email for this project, too:

git config user.name USERNAME
git config user.email USERNAME@example.com

Upvotes: 301

bobobobo

Reputation: 67326

Use https for repository action using a secondary id

Make a PAT
Use the https versions of clone & push

In the following, your github.com sign in is GITHUBUSERNAME, and the repo you are operating on is REPONAME.

Clone

git clone https://github.com/GITHUBUSERNAME/REPONAME.git

Push

git push https://GITHUBUSERNAME@github.com/GITHUBUSERNAME/REPONAME.git

When you push using this method, you will be presented with a dialog box when you push:

github enter password PAT dialog

You have to enter your PAT that you created in step 1. Your PAT will look like a 40 character letter/number hash, like

zIa03uTnN0TTaReAALT09K33NMBbCfum6lw8TDSb

If you get the message

remote: Support for password authentication was removed on August 13, 2021.

You probably have a mistake in your PAT or you're trying to use the same password that you log into the website with. You can't use the password you log into github.com to push your commits. You have to use a PAT.

The only thing they need to do is 2FA for commits!!

Upvotes: 0

Edgardo Arriagada

Reputation: 86

in your ~./gitconfig CAREFULLY add:

[url "git@github.com:{my_username}"]
  insteadOf = https://github.com/{my_username}
[url "git@github.com{-my_org_short}:{my_org_name}/"]
  insteadOf = https://github.com/{my_org_name}/
  insteadOf = git@github.com:{my_org_name}/

where {-my_org_short} is optional

you may play adding your org username instead of {my_org_name} in the url section depending on your github setup

Simple approach without dealing with SSH keypairs

Just change the user.name & user.email locally in the repo. to the ones you want to push to that repo with.

Example: I have a work account in gitlab having a project. After cloning this project/repo, in the terminal, I type out:

git config user.name "my-work-username"
git config user.email "my-work-email-id"

Now, say I've another personal project/repo in Gitlab that I want to associate with my personal account. Just like above, after cloning, I type:

git config user.name "my-personal-username"
git config user.email "my-personal-email-id"

Hope this helps. Upvote if it worked for you! :)

Upvotes: 2

Raja Shakir

Reputation: 97

Simpler and Easy fix to avoid confusion..

For Windows users to use multiple or different git accounts for different projects.

Following steps:
Go Control Panel and Search for Credential Manager. Then Go to Credential Manager -> Windows Credentials

Now remove the git:https//github.com node under Generic Credentials Heading

This will remove the current credentials. Now you can add any project through git pull it will ask for username and password.

When you face any issue with other account do the same process.

refer to image

Upvotes: 8

Abu Shoeb

Reputation: 5152

I see a lot of possible workarounds here. As a quick fix, @Greg's one seems relatively easy. However, it's best to set up separate ssh keys for all different accounts in the long run. This video demonstrates it briefly. Here are the steps mentioned in that video blog.

Step 1 - Create a New SSH Key for a new account and save it in a separate file (e.g. ~/.ssh/id_rsa_new_account_name), not in the original file i.e. ~/.ssh/id_rsa

ssh-keygen -t rsa -C "your-email-address"

Step 2 - Attach the New Key

Next, login to your second GitHub account
Browse to Account Overview, and attach the new key ~/.ssh/id_rsa_new_account_name.pub within the SSH Public Keys section.
In the Terminal, tell SSH to add the new identity by typing ssh-add ~/.ssh/id_rsa_new_account_name. If successful, you'll see a response of Identity Added.

Step 3 - Create a Config File

touch ~/.ssh/config

And save the following contents into the file

#Default GitHub
Host github.com
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_rsa

#New Account
Host github-new-account-name
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_rsa_new_account_name

Step 4 - Try it Out Now every time you want to use the new account and the associated repo, type this for the respective repo

git remote add origin git@github-new-account-name:your-domain.com/your-repo.git

Upvotes: 5

Jatin verma

Reputation: 71

Instead you just add your new email id to your personal git account. This way you don't need to add another SSH key. Just configure your new email by doing git config --global user.email newemail. Then you will be able to clone that repo.

Upvotes: -1

vishva

Reputation: 59

There could be multiple way to do it but Following solution works for me and very simple. I am not trying to do it with SSH, my steps and solution is based on HTTPS.

Create your project DIR on your local machine. Example d:\test_git_multiple_account
go to the folder "test_git_multiple_account"
Add few files here into the DIR

Open Git bash here and run following command

a. git init // initialization 
b. git add , // add 
c. git commit -m "initial commit"
    you will get following output : in my case i use to add one python file created 
    from code.
    **[master (root-commit) d4defd9] initial commit
    2 files changed, 4 insertions(+)
    create mode 100644 .vscode/settings.json
    create mode 100644 Hello.py**

d.  git remote add origin <HTTPS repo link>
e.  git remote -v // check the repo version 
f.  git push origin master
    it will ask your git hub user name and password via popup screen. 
    you will get the following output 
    Counting objects: 100% (5/5), done.
    Delta compression using up to 4 threads
    Compressing objects: 100% (3/3), done.
    Writing objects: 100% (5/5), 411 bytes | 31.00 KiB/s, done.
    Total 5 (delta 0), reused 0 (delta 0), pack-reused 0
    remote:
    remote: Create a pull request for 'master' on GitHub by visiting:
    remote:      https://github.com/vishvadeepaktripathi/Hello_Py/pull/new/master
    remote:
    To https://github.com/vishvadeepaktripathi/Hello_Py.git
     * [new branch]      master -> master

This will create new branch as i named here called master. You can commit into main branch once you change the branch in this case your existing file will be delete. So i would recommend that to checkout into main branch into First step then proceed for every command in case you want to checkout directly into main branch. Caution At the First login it might give you an error message and ask again for login and password and then it will publish your change into Git hub.

Once this is done you will get message to new pull request into your github account. you can merge your changes from master branch to the main branch.

i created master branch here you named your branch as per your choice. Attaching the screen shot as well. enter image description here

Upvotes: 0

Dragos

Reputation: 44

Change the authentication method in github from SSh to HTTP. This way it will not care if you are logged with your work github account and you try to remotely interact with your personal github account (which has different credentials than the ones you are currently logged with onto your local machine).

Upvotes: 0

Mulan

Reputation: 135416

Getting into shape

To manage a git repo under a separate github/bitbucket/whatever account, you simply need to generate a new SSH key.

But before we can start pushing/pulling repos with your second identity, we gotta get you into shape – Let's assume your system is setup with a typical id_rsa and id_rsa.pub key pair. Right now your tree ~/.ssh looks like this

$ tree ~/.ssh
/Users/you/.ssh
├── known_hosts
├── id_rsa
└── id_rsa.pub

First, name that key pair – adding a descriptive name will help you remember which key is used for which user/remote

# 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

Next, let's generate a new key pair – here I'll name the new key github-otheruser

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

Now, when we look at tree ~/.ssh we see

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

Next, we need to setup a ~/.ssh/config file that will define our key configurations. We'll create it with the proper owner-read/write-only permissions

$ (umask 077; touch ~/.ssh/config)

Open that with your favourite editor, and add the following contents

Host github.com
  User git
  IdentityFile ~/.ssh/github-mainuser

Host github.com-otheruser
  HostName github.com
  User git
  IdentityFile ~/.ssh/github-otheruser

Presumably, you'll have some existing repos associated with your primary github identity. For that reason, the "default" github.com Host is setup to use your mainuser key. If you don't want to favour one account over another, I'll show you how to update existing repos on your system to use an updated ssh configuration.

Add your new SSH key to github

Head over to github.com/settings/keys to add your new public key

You can get the public key contents using: copy/paste it to github

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

Now your new user identity is all setup – below we'll show you how to use it.

Getting stuff done: cloning a repo

So how does this come together to work with git and github? Well because you can't have a chicken without and egg, we'll look at cloning an existing repo. This situation might apply to you if you have a new github account for your workplace and you were added to a company project.

Let's say github.com/someorg/somerepo already exists and you were added to it – cloning is as easy as

$ git clone github.com-otheruser:someorg/somerepo.git

That bolded portion must match the Host name we setup in your ~/.ssh/config file. That correctly connects git to the corresponding IdentityFile and properly authenticates you with github

Getting stuff done: creating a new repo

Well because you can't have a chicken without and egg, we'll look at publishing a new repo on your secondary account. This situation applies to users that are create new content using their secondary github account.

Let's assume you've already done a little work locally and you're now ready to push to github. You can follow along with me if you'd like

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

Now configure this repo to use your identity

$ git config user.name "Mister Manager"
$ git config user.email "someuser@some.org"

Now make your first commit

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

Check the commit to see your new identity was used using git log

$ git log --pretty="%H %an <%ae>"
f397a7cfbf55d44ffdf87aa24974f0a5001e1921 Mister Manager <someuser@some.org>

Alright, time to push to github! Since github doesn't know about our new repo yet, first go to github.com/new and create your new repo – name it somerepo

Now, to configure your repo to "talk" to github using the correct identity/credentials, we have add a remote. Assuming your github username for your new account is someuser ...

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

That bolded portion is absolutely critical and it must match the Host that we defined in your ~/.ssh/config file

Lastly, push the repo

$ git push origin master

Update an existing repo to use a new SSH configuration

Say you already have some repo cloned, but now you want to use a new SSH configuration. In the example above, we kept your existing repos in tact by assigning your previous id_rsa/id_rsa.pub key pair to Host github.com in your SSH config file. There's nothing wrong with this, but I have at least 5 github configurations now and I don't like thinking of one of them as the "default" configuration – I'd rather be explicit about each one.

Before we had this

Host github.com
  User git
  IdentityFile ~/.ssh/github-mainuser

Host github.com-otheruser
  HostName github.com
  User git
  IdentityFile ~/.ssh/github-otheruser

So we will now update that to this (changes in bold)

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

But now any existing repo with a github.com remote will not work with this identity file. But don't worry, it's a simple fix.

To update any existing repo to use your new SSH configuration, update the repo's remote origin field using set-url -

$ cd existingrepo
$ git remote set-url origin github.com-mainuser:someuser/existingrepo.git

That's it. Now you can push/pull to your heart's content

SSH key file permissions

If you're running into trouble with your public keys not working correctly, SSH is quite strict on the file permissions allowed on your ~/.ssh directory and corresponding key files

As a rule of thumb, any directories should be 700 and any files should be 600 - this means they are owner-read/write-only – no other group/user can read/write them

$ 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

How I manage my SSH keys

I manage separate SSH keys for every host I connect to, such that if any one key is ever compromised, I don't have to update keys on every other place I've used that key. This is like when you get that notification from Adobe that 150 million of their users' information was stolen – now you have to cancel that credit card and update every service that depends on it – what a nuisance.

Here's what my ~/.ssh directory looks like: I have one .pem key for each user, in a folder for each domain I connect to. I use .pem keys to so I only need one file per key.

$ tree ~/.ssh
/Users/myuser/.ssh
├── another.site
│   ├── myuser.pem
├── config
├── github.com
│   ├── myuser.pem
│   ├── someusername.pem
├── known_hosts
├── somedomain.com
│   ├── someuser.pem
└── someotherdomain.org
     └── root.pem

And here's my corresponding /.ssh/config file – obviously the github stuff is relevant to answering this question about github, but this answer aims to equip you with the knowledge to manage your ssh identities on any number of services/machines.

Host another.site
  User muyuser
  IdentityFile ~/.ssh/another.site/muyuser.pem

Host github.com-myuser
  HostName github.com
  User git
  IdentityFile ~/.ssh/github.com/myuser.pem

Host github.com-someuser
  HostName github.com
  User git
  IdentityFile ~/.ssh/github.com/someusername.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/root.pem

Getting your SSH public key from a PEM key

Above you noticed that I only have one file for each key. When I need to provide a public key, I simply generate it as needed.

So when github asks for your ssh public key, run this command to output the public key to stdout – copy/paste where needed

$ ssh-keygen -y -f someuser.pem
ssh-rsa AAAAB3NzaC1yc2EAAAA...

Note, this is also the same process I use for adding my key to any remote machine. The ssh-rsa AAAA... value is copied to the remote's ~/.ssh/authorized_keys file

Converting your id_rsa/id_rsa.pub key pairs to PEM format

So you want to tame you key files and cut down on some file system cruft? Converting your key pair to a single PEM is easy

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

Or, following along with our examples above, we renamed id_rsa -> github-mainuser and id_rsa.pub -> github-mainuser.pub – so

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

Now just to make sure that we've converted this correct, you will want to verify that the generated public key matches your old public key

# 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==

Now that you have your github-mainuser.pem file, you can safely delete your old github-mainuser and github-mainuser.pub files – only the PEM file is necessary; just generate the public key whenever you need it ^_^

Creating PEM keys from scratch

You don't need to create the private/public key pair and then convert to a single PEM key. You can create the PEM key directly.

Let's create a newuser.pem

$ openssl genrsa -out ~/.ssh/newuser.pem 4096

Getting the SSH public key is the same

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

Upvotes: 182

Detoner

Reputation: 604

Manage multiple GitHub accounts on one Windows machine (HTTPS)

Let's say you previously use git on your machine and configure git global config file. To check it open the terminal and :

git config --global -e

It opens your editor, and you may see something like this:

[user]
    email = yourEmail@gmail.com
    name = Your_Name
...

And this is great because you can push your code to GitHub account without entering credentials every time. But what if it needs to push to repo from another account? In this case, git will reject with 403 err, and you must change your global git credentials. To make this comfortable lat set storing a repo name in a credential manager:

git config --global credential.github.com.useHttpPath true

to check it open config one more time git config --global -e you will see new config lines

[credential]
    useHttpPath = true
...

The is it. Now when you first time push to any account you will see a pop-up Screenshot_1

Enter specific for this repo account credentials, and this will "bind" this account for the repo. And so in your machine, you can specify as many accounts/repos as you want.

For a more expanded explanation you can see this cool video that I found on youtube: https://youtu.be/2MGGJtTH0bQ

Upvotes: 1

Leo Lloyd Andrade

Reputation: 49

Got my private repo working using SSH key pairs. This was tested on git for Windows.

Source: https://docs.github.com/en/free-pro-team@latest/github/authenticating-to-github/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent

A. Generate public and private key pairs

Start git bash
Run ssh-keygen -t ed25519 -C "your_email@example.com"
When you're prompted to "Enter a file in which to save the key," press Enter to accept the default.
Press enter for a blank passphrase.
Start the ssh agent: eval $(ssh-agent)
Add private key to ssh agent and store the passphrase: ssh-add ~/.ssh/id_ed25519

B. Add SSH keys to GitHub account

Copy the public key to the clipboard: clip < ~/.ssh/id_ed25519.pub
On GitHub, go to Profile -> Settings -> SSH Keys -> New SSH Key
Give a title. E.g. "Windows on MacBook Pro"
Paste the key and hit "Add SSH Key".

C. Test SSH connection

Enter: ssh -T git@github.com
Hit "yes" for any warning message.
It should show: "Hi username!..." indicating a successful test.

D. Setup local repository to use SSH keys

Change email and user name:

git config user.email your_email@example.com
git config user.name github_username

Update remote links to use git. First list remote URI's:

git remote -v
git remote set-url origin git@github.com:github_username/your-repo-name.git

E. Test

git remote show origin

Upvotes: 3

nphias

Reputation: 619

Option 0: you dont want to mess around with OS settings.. you just want to commit to a different github account with a different public key for one repo.

solution:

create the new key: ssh-keygen -t rsa -b 4096 -f ~/.ssh/alt_rsa
add the key to the keyset: ssh-add -K ~/.ssh/alt_rsa
copy and add the pub key to the github account: (see github instructions)
test the key with github: ssh -i ~/.ssh/alt_rsa T git@github.com
clone the repo using the git protocol (not HTTP): git clone git@github:myaccount...
in the cloned repo:

git config core.sshCommand "ssh -i ~/.ssh/alt_rsa -F /dev/null"
git config user.name [myaccount]
git config user.email [myaccount email]
now you should be able to git push correctly without interferring with your everyday git account

Upvotes: 1

What Would Be Cool

Reputation: 6808

Personal Directory `.gitconfig` using a personal access token

If you do not want to modify your host file, use SSH keys, or setup a .gitconfig for each repo, then you may use a personal .gitconfig that you basically include from the root level config. Given an OSX directory structure like

# root level git config
~/.gitconfig

# your personal repos under some folder like
../personal/
../home/
~/Dropbox/

Add a .gitconfig in your personal folder, such as ~/Dropbox/.gitconfig

[user]
    email = first.last@home.com
    name = First Last
[credential]
    username = PersonalGithubUsername
    helper = osxkeychain

In your root level .gitconfig add an includeIf section to source your personal config whenever you are in your personal directory. Any settings there will override the root config as long as the includeIf comes after the settings you want to override.

[user]
    email = first.last@work.com
    name = "First Last"
[credential]
    helper = osxkeychain
[includeIf "gitdir:~/Dropbox/**"]
    path = ~/Dropbox/.gitconfig

Try pushing to your personal repo or pulling from your private repo

git push
# prompts for password

When prompted enter either your personal password or, better yet, your personal access token that you have created in your account developer settings. Enter that token as your password.

Assuming you are already using git-credential-osxkeychain, your personal credentials should be stored in your keychain, so two github entries will show up, but with different accounts.

Upvotes: 1

Rishi Raj

Reputation: 422

If you have created or cloned another repository and you were not able to pull from origin or upstream adding the ssh key at that directory using the following command worked.

This is the error I was getting here:

Warning: Permanently added the RSA host key for IP address '61:fd9b::8c52:7203' to the list of known hosts.
Permission denied (publickey).
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.

I used the following command, this works:

ssh-add ~/.ssh/id_rsa_YOUR_COMPANY_NAME

Upvotes: 0

daemonThread

Reputation: 1044

Navigate to the directory in which you want to push your changes to a different GitHub account.
Create a new SSH key in your terminal/command line.

ssh-keygen -t rsa -C “your-email-address”
The following will then show:

Generating public/private rsa key pair. Enter file in which to save the key (/home/your_username/.ssh/id_rsa):

Copy and paste the path followed by an identifiable name for the file:

/home/your_username/.ssh/id_rsa_personal

4) It will then ask you for the following:

Enter passphrase (empty for no passphrase):
Enter same passphrase again:

5) You can now type in the following command to see all the SSH keys you have on your local machine:

ls -al ~/.ssh

You should be able to see your new SSH key file. As you can see in my one I have both id_rsa_test and id_rsa_personal.pub.

drwx------  2 gmadmin gmadmin 4096 Nov 16 22:20 .
drwxr-xr-x 42 gmadmin gmadmin 4096 Nov 16 21:03 ..
-rw-------  1 gmadmin gmadmin 1766 Nov 16 22:20 id_rsa_personal
-rw-r--r--  1 gmadmin gmadmin  414 Nov 16 22:20 id_rsa_personal.pub
-rw-r--r--  1 gmadmin gmadmin  444 Nov  6 11:32 known_hosts

6) Next you need to copy the SSH key which is stored in id_rsa_personal.pub file. You can open this in text editor of your choice. I am currently using atom so I opened the file using the following command:

atom ~/.ssh/id_rsa_personal.pub

You will then get something similar to this:

ssh-rsa AAB3HKJLKC1yc2EAAAADAQABAAABAQCgU5+ELtwsKkmcoeF3hNd7d6CjW+dWut83R/Dc01E/YzLc5ZFri18doOwuQoeTPpmIRVDGuQQsZshjDrTkFy8rwKWMlXl7va5olnGICcpg4qydEtsW+MELDmayW1HHsi2xHMMGHlNv

7) Copy this and navigate to your GitHub account → Settings → SSH and GPG keys 8) Click on New SSH key. Copy the key, give it a title and add it. 9) Add key from terminal

ssh-add ~/.ssh/id_rsa_personal
Enter passphrase for /home/your_username/.ssh/id_rsa_personal:

10) Configure user and password.

git config --global user.name "gitusername"
git config --global user.email "gitemail"

11) We are ready to commit and push now.

git init
git add .
git commit 
git push

Upvotes: 0

thakis

Reputation: 5919

In case you don't want to mess with the ~/.ssh/config file mentioned here, you could instead run git config core.sshCommand "ssh -i ~/.ssh/custom_id_rsa" in the repo where you want to commit from a different account.

The rest of the setup is the same:

Create a new SSH key for the second account with ssh-keygen -t rsa -f ~/.ssh -f ~/.ssh/custom_id_rsa
Sign in to github with your other account, go to https://github.com/settings/keys , and paste the contents of ~/.ssh/custom_id_rsa.pub
Make sure you're using SSH instead of HTTPS as remote url: git remote set-url origin git@github.com:upstream_project_teamname/upstream_project.git

Upvotes: 5

Multiple GitHub accounts on the same computer?

Answers (30)

Generate a Personal Access Token

Clone the Repository

Configure Git User

Authenticate Git:

For MacOS - Using gh CLI

Use HTTPS

Clone

Push

Simple approach without dealing with SSH keypairs

A. Generate public and private key pairs

B. Add SSH keys to GitHub account

C. Test SSH connection

D. Setup local repository to use SSH keys

E. Test

Personal Directory .gitconfig using a personal access token

Related Questions

Personal Directory `.gitconfig` using a personal access token