Più account github sullo stesso computer?

Sto provando a lavorare sia sul mio attuale repository "lavoro", sia sul mio repository personale su git hub, dal mio computer.

L'account di lavoro è stato creato per primo e tutto funziona alla perfezione.

Il mio account personale, tuttavia, non sembra inoltrare al mio repository personale, impostato con un account / e-mail diverso.

Ho provato a copiare la mia chiave di lavoro sul mio account personale, ma questo genera un errore, perché ovviamente una chiave può essere collegata a un solo account.

Come posso inviare / estrarre da e verso entrambi gli account, dalle rispettive credenziali github?

Tutto quello che devi fare è configurare la tua configurazione SSH con più coppie di chiavi SSH.

• Questo link è facile da seguire (Grazie Eric): http://code.tutsplus.com/tutorials/quick-tip-how-to-work-with-github-and-multiple-accounts--net-22574

• Generazione di chiavi SSH (Win / msysgit) https://help.github.com/articles/generating-an-ssh-key/

Inoltre, se si lavora con più repository utilizzando persone diverse, è necessario assicurarsi che i singoli repository abbiano le impostazioni utente sovrascritte di conseguenza:

Impostazione di nome utente, e-mail e token GitHub - Sostituzione delle impostazioni per singoli repository https://help.github.com/articles/setting-your-commit-email-address-in-git/

Spero che sia di aiuto.

Nota: alcuni di voi potrebbero richiedere l'utilizzo di e-mail diverse per repository diversi, da git 2.13 è possibile impostare l'e-mail su una base di directory modificando il file di configurazione globale che si trova in: ~/.gitconfigusando le condizioni in questo modo:

[user]
    name = Pavan Kataria
    email = defaultemail@gmail.com

[includeIf "gitdir:~/work/"]
    path = ~/work/.gitconfig

E quindi il tuo lavoro specifico config ~ / work / .gitconfig sarebbe simile a questo:

[user]
    email = pavan.kataria@company.tld

Grazie @alexg per avermi informato di questo nei commenti.

Usa HTTPS:

cambia l'URL remoto in https:

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

e sei a posto:

git push

Per garantire che i commit appaiano come eseguiti da USERNAME, è possibile impostare anche user.name e user.email per questo progetto:

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

Mettersi in forma

Per gestire un repository git con un account github / bitbucket / qualunque separato, devi semplicemente generare una nuova chiave SSH.

Ma prima di poter iniziare a spingere / estrarre i repository con la tua seconda identità, dobbiamo rimetterti in forma - Supponiamo che il tuo sistema sia configurato con una coppia tipica id_rsae id_rsa.pubchiave. In questo momento il tuo tree ~/.sshassomiglia a questo

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

Innanzitutto, assegna un nome a quella coppia di chiavi: l'aggiunta di un nome descrittivo ti aiuterà a ricordare quale chiave viene utilizzata per quale utente / telecomando

# 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

Quindi, generiamo una nuova coppia di chiavi : qui nominerò la nuova chiavegithub-otheruser

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

Ora, quando guardiamo tree ~/.ssh, vediamo

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

Successivamente, dobbiamo impostare un ~/.ssh/configfile che definirà le nostre configurazioni chiave. Lo creeremo con le autorizzazioni appropriate di sola lettura / scrittura del proprietario

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

Aprilo con il tuo editor preferito e aggiungi i seguenti contenuti

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

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

Presumibilmente, avrai alcuni repository esistenti associati alla tua identità github primaria. Per questa ragione, il "predefinito" github.com Hostè configurato per usare la tua mainuserchiave. Se non vuoi favorire un account rispetto a un altro, ti mostrerò come aggiornare i repository esistenti sul tuo sistema per utilizzare una configurazione ssh aggiornata.

Aggiungi la tua nuova chiave SSH a github

Vai su github.com/settings/keys per aggiungere la tua nuova chiave pubblica

Puoi ottenere il contenuto della chiave pubblica usando: copia / incolla su github

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

Ora la tua nuova identità utente è tutta configurata - di seguito ti mostreremo come usarla.

Fare cose: clonare un repository

Quindi, come si fa a lavorare insieme con git e github? Bene perché non puoi avere un pollo senza e un uovo, vedremo come clonare un repository esistente. Questa situazione potrebbe applicarsi a te se hai un nuovo account github per il tuo posto di lavoro e sei stato aggiunto a un progetto aziendale.

Diciamo che github.com/someorg/somerepoesiste già e ti è stato aggiunto - la clonazione è facile come

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

Quella parte in grassetto deve corrispondere al Hostnome che abbiamo impostato nel tuo ~/.ssh/configfile. Che collega correttamente Git al corrispondente IdentityFilee ti autentica correttamente con Github

Fare cose: creare un nuovo repository

Bene perché non puoi avere un pollo senza e un uovo, vedremo la pubblicazione di un nuovo repository sul tuo account secondario. Questa situazione si applica agli utenti che creano nuovi contenuti utilizzando il proprio account github secondario.

Supponiamo che tu abbia già fatto un po 'di lavoro a livello locale e ora sei pronto a spingere su Github. Puoi seguirmi se vuoi

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

Ora configura questo repository per usare la tua identità

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

Ora fai il tuo primo commit

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

Controlla il commit per vedere che la tua nuova identità è stata usata usando git log

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

Bene, è ora di spingere su Github! Poiché github non è ancora a conoscenza del nostro nuovo repository, prima vai su github.com/new e crea il tuo nuovo repository - chiamalo somerepo

Ora, per configurare il tuo repository affinché "parli" con github usando l'identità / le credenziali corrette, abbiamo aggiunto un telecomando. Supponendo che il tuo nome utente github per il tuo nuovo account sia someuser...

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

Quella parte in grassetto è assolutamente fondamentale e deve corrispondere a quella Hostche abbiamo definito nel tuo ~/.ssh/configfile

Infine, spingere il repository

$ git push origin master

Aggiorna un repository esistente per utilizzare una nuova configurazione SSH

Supponiamo che tu abbia già clonato alcuni repository, ma ora desideri utilizzare una nuova configurazione SSH. Nell'esempio sopra, abbiamo mantenuto intatti i tuoi repository esistenti assegnando la tua coppia precedente id_rsa/ id_rsa.pubchiave al Host github.comtuo file di configurazione SSH. Non c'è niente di sbagliato in questo, ma ora ho almeno 5 configurazioni github e non mi piace pensare a una di esse come la configurazione "predefinita" - Preferirei essere esplicita su ognuna.

Prima che avessimo questo

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

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

Quindi ora aggiorneremo questo a questo (modifiche in grassetto )

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

github.comCiò significa che ora qualsiasi repository esistente con un telecomando non funzionerà più con questo file di identità. Ma non preoccuparti, è una soluzione semplice.

Per aggiornare un repository esistente per utilizzare la nuova configurazione SSH, è sufficiente aprire il file di configurazione git del repository e aggiornare l'URL!

$ cd existingrepo
$ nano .git/config

Aggiorna il campo di origine remoto (modifiche in grassetto )

[remote "origin"]
        url = github.com-mainuser:someuser/existingrepo.git
        fetch = +refs/heads/*:refs/remotes/origin/*

Questo è tutto. Ora puoi push/ pullal contenuto del tuo cuore

Autorizzazioni per file chiave SSH

Se stai riscontrando problemi con le tue chiavi pubbliche non funzionano correttamente, SSH è piuttosto severo sulle autorizzazioni dei file consentite sulla tua ~/.sshdirectory e sui file delle chiavi corrispondenti

Come regola generale, tutte le directory dovrebbero essere 700e tutti i file dovrebbero essere 600- questo significa che sono di sola lettura / scrittura del proprietario - nessun altro gruppo / utente può leggerli / scriverli

$ 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

Come gestisco le mie chiavi SSH

Gestisco chiavi SSH separate per ogni host a cui mi connetto, in modo tale che se una qualsiasi chiave viene mai compromessa, non devo aggiornare le chiavi in ​​ogni altro posto in cui ho usato quella chiave. È come quando ricevi la notifica da Adobe che sono state rubate 150 milioni delle informazioni dei loro utenti - ora devi cancellare quella carta di credito e aggiornare tutti i servizi che dipendono da essa - che seccatura.

Ecco ~/.sshcome appare la mia directory: ho una .pemchiave per ogni utente, in una cartella per ogni dominio a cui mi connetto. Uso le .pemchiavi per aver bisogno di un solo file per chiave.

$ tree ~/.ssh
/Users/naomik/.ssh
├── config
├── github.com
│   ├── naomik.pem
│   ├── someusername.pem
├── known_hosts
├── naomi.makes.software
│   ├── naomi.pem
├── somedomain.com
│   ├── someuser.pem
└── someotherdomain.org
    └── someuser.pem

Ed ecco il mio /.ssh/configfile corrispondente - ovviamente la roba di github è rilevante per rispondere a questa domanda su github, ma questa risposta ha lo scopo di fornirti le conoscenze per gestire le tue identità ssh su qualsiasi numero di servizi / macchine.

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

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

Host naomi.makes.software
  User naomi
  IdentityFile ~/.ssh/naomi.makes.software/naomi.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/someuser.pem

Ottenere la chiave pubblica SSH da una chiave PEM

Sopra hai notato che ho solo un file per ogni chiave. Quando ho bisogno di fornire una chiave pubblica, la generi semplicemente secondo necessità.

Quindi quando github richiede la tua chiave pubblica ssh, esegui questo comando per generare la chiave pubblica su stdout - copia / incolla dove necessario

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

Nota, questo è anche lo stesso processo che uso per aggiungere la mia chiave a qualsiasi macchina remota. Il ssh-rsa AAAA...valore viene copiato nel ~/.ssh/authorized_keysfile del telecomando

Conversione delle coppie id_rsa/ id_rsa.pubchiave in formato PEM

Quindi vuoi domare i tuoi file chiave e ridurti a qualche cruft di file system? Convertire la coppia di chiavi in ​​un singolo PEM è semplice

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

Oppure, seguendo i nostri esempi precedenti, abbiamo rinominato id_rsa -> github-mainusere id_rsa.pub -> github-mainuser.pub- così

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

Ora solo per assicurarci di averlo convertito correttamente, vorrai verificare che la chiave pubblica generata corrisponda alla tua vecchia chiave pubblica

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

Ora che hai il tuo github-mainuser.pemfile, puoi tranquillamente eliminare i tuoi vecchi github-mainusere github-mainuser.pubfile - è necessario solo il file PEM; genera la chiave pubblica ogni volta che ti serve ^ _ ^

Creazione di chiavi PEM da zero

Non è necessario creare la coppia di chiavi privata / pubblica e quindi convertirla in una singola chiave PEM. È possibile creare direttamente la chiave PEM.

Creiamo un newuser.pem

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

Ottenere la chiave pubblica SSH è la stessa

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

Creando alias host diversi su github.com nella tua ~ / .ssh / config e dando ad ogni alias host la propria chiave ssh, puoi facilmente usare più account github senza confusione. Questo perché github.com distingue non per utente, che è sempre solo git, ma per il tasto ssh che hai usato per connetterti. Configura le tue origini remote usando i tuoi alias host. "

Il riepilogo sopra è per gentile concessione di commenti sul post di blog qui sotto.

Ho trovato questa spiegazione la più chiara. E funziona per me, almeno dall'aprile 2012.

http://net.tutsplus.com/tutorials/tools-and-tips/how-to-work-with-github-and-multiple-accounts/

I dettagli su http://net.tutsplus.com/tutorials/tools-and-tips/how-to-work-with-github-and-multiple-accounts/ collegati da mishaba funzionano molto bene per me.

Da quella pagina:

$ touch ~/.ssh/config

Quindi modifica quel file in modo che sia simile a questo (una voce per account):

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

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

• Vai a ~ / .ssh
• Crea un file chiamato config (non ha estensione)

• Apri il file di configurazione e aggiungi i codici seguenti. (cambia in base al tuo account)

  1. Conto 1

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

  2. Conto 2

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

  3. Conto 3

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

• Aggiungi l'URL remoto come segue

  1. Conto 1

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

  2. Conto 2

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

  3. Conto 3

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

Assicurarsi che i nomi IdentityFile siano gli stessi creati durante la generazione della chiave ssh.

Uso gli script di shell per passare a qualsiasi account che voglio essere "attivo". Fondamentalmente si parte da un nuovo inizio, si ottiene un account configurato correttamente e funzionante, quindi si sposta questi file su un nome con il prefisso appropriato. Da quel momento in poi puoi usare il comando "github" o "gitxyz" per cambiare:

# my github script
cd ~/.ssh

if [ -f git_dhoerl -a -f git_dhoerl.pub -a -f config_dhoerl ]
then
    ; 
else 
    echo "Error: missing new files"
    exit 1
fi 

# Save a copy in /tmp, just in case
cp id_rsa /tmp
cp id_rsa.pub /tmp
cp config /tmp
echo "Saved old files in /tmp, just in case"

rm id_rsa
rm id_rsa.pub
rm config
echo "Removed current links/files"

ln git_dhoerl id_rsa
ln git_dhoerl.pub id_rsa.pub
ln config_dhoerl config

git config --global user.email "dhoerl@<company>.com"
git config --global github.user "dhoerl"        
git config --global github.token "whatever_it_is"

ssh-add -D

Ho avuto molta fortuna con questo. Ho anche creato uno script di esecuzione in Xcode (per te utenti Mac) in modo che non costruisse il mio progetto a meno che non avessi l'impostazione corretta (dal momento che usa git):

Esegui script collocato dopo le dipendenze (usando / bin / ksh come shell):

if [ "$(git config --global --get user.email)" != "dhoerl@<company>.com" ]
then
    exit 1
fi

EDIT: aggiunti test per l'esistenza di nuovi file e copia di vecchi file in / tmp per rispondere ai commenti di @naomik di seguito.

Questa risposta è per i principianti (nessuno git guru) . Di recente ho avuto questo problema e forse sono solo io, ma la maggior parte delle risposte sembra richiedere una comprensione piuttosto avanzata di git. Dopo aver letto diverse risposte di overflow dello stack, incluso questo thread, ecco i passaggi che dovevo prendere per passare facilmente da un account GitHub (ad esempio, supponiamo a due account GitHub, github.com/personal e gitHub.com/work ):

1. Controlla le chiavi ssh esistenti: Apri Terminale ed esegui questo comando per vedere / elencare ils -al ~/.ssh
   file dellechiavi ssh esistenticon estensione.pubsono le tue chiavi ssh, quindi dovresti averne due per gliaccountpersonalework. Se ce n'è solo uno o nessuno, è tempo di generare altri saggi salta questo.
   
   - Generazione del tasto ssh : accedi a github (secondo l'accordo personale o di lavoro), vai su Impostazioni e copia l'e-mail associata.
   ora torna al Terminale ed eseguissh-keygen -t rsa -C "the copied email", vedrai:
   
   Generazione coppia di chiavi rsa pubbliche / private.
   Inserisci il file in cui salvare la chiave (/.../.ssh/id_rsa):
   
   id_rsa è il nome predefinito per la chiave ssh che verrà presto generata, quindi copia il percorso e rinomina il valore predefinito, ad es. /.../.ssh/id_rsa_workse si genera per account di lavoro. fornire una password o semplicemente inserire per ignorare e, leggerai qualcosa di simile L'immagine casuale della chiave è: e l'immagine. fatto.
   Ripeti questo passaggio ancora una volta per il tuo secondo account github. Assicurati di utilizzare l'indirizzo e-mail corretto e un nome chiave ssh diverso (ad esempio id_rsa_personal) per evitare la sovrascrittura.
   A questo punto, dovresti vedere due tasti ssh quando esegui di ls -al ~/.sshnuovo.
2. Associare la chiave ssh all'account gitHub: il prossimo passo è copiare una delle chiavi ssh, eseguirla ma sostituendo il proprio nome della chiave ssh :,pbcopy < ~/.ssh/id_rsa_work.pub sostituire id_rsa_work.pubcon quello che hai chiamato tuo.
   Ora che la nostra chiave SSH viene copiato negli appunti, torna al conto github [Assicurati di aver effettuato l'accesso al conto lavoro se la chiave SSH è stato copiato è id_rsa_work] e passare a
   Impostazioni - SSH e chiavi GPG e fare clic sul tasto Nuovo SSH pulsante (non Nuova chiave GPG btw: D)
   assegnare un titolo per questa chiave, incollare la chiave e fare clic su Aggiungi chiave SSH. Ora hai aggiunto correttamente la chiave ssh o hai notato che è sempre stato lì, il che va bene (o hai ricevuto un errore perché hai selezionato Nuova chiave GPG invece diNuova chiave SSH : D).
3. Associare la chiave ssh all'account gitHub : ripetere il passaggio precedente per il secondo account.

4. Modifica la configurazione globale di git: l' ultimo passo è assicurarti che il file di configurazione globale sia a conoscenza di tutti gli account github (per così dire).
   Esegui git config --global --editper modificare questo file globale, se questo apre vim e non sai come usarlo, premi iper accedere alla modalità Inserisci, modificare il file come sotto e premere esc seguito da :wqper uscire dalla modalità inserimento:

   [inside this square brackets give a name to the followed acc.] name = github_username email = github_emailaddress [any other name] name = github_username email = github_email [credential] helper = osxkeychain useHttpPath = true

Fatto !, ora quando provi a eseguire il push o il pull da un repository, ti verrà chiesto quale account GitHub dovrebbe essere collegato a questo repository e viene chiesto solo una volta, la configurazione locale ricorderà questo link e non la configurazione globale in modo da poter lavorare su repository diversi che sono collegati con account diversi senza dover modificare ogni volta la configurazione globale.

Correzione più semplice e facile per evitare confusioni ..

Per gli utenti Windows utilizzare account git multipli o diversi per progetti diversi.

Passaggi seguenti: Vai al Pannello di controllo e Cerca Credential Manager. Quindi vai a Gestione credenziali -> Credenziali di Windows

Ora rimuovi il nodo git: https // github.com in Intestazione credenziali generiche

Ciò rimuoverà le credenziali correnti. Ora puoi aggiungere qualsiasi progetto tramite git pull che ti chiederà username e password.

In caso di problemi con altri account, fare lo stesso processo.

Grazie

fare riferimento all'immagine

ho appena capito questo per Windows, usando le credenziali per ogni repository:

cd c:\User1\SomeRepo
git config --local credential.https://github.com.user1 user1
git config --local credential.useHttpPath true
git config --local credential.helper manager
git remote set-url origin https://USERNAME@github.com/USERNAME/PROJECTNAME.git

Il formato delle credenziali. https://github.com . comunica all'helper delle credenziali l'URL della credenziale. "UseHttpPath" indica al gestore delle credenziali di utilizzare il percorso per le credenziali. Se useHttpPath viene omesso, il gestore delle credenziali memorizzerà una credenziale per https://github.com . Se è incluso, il gestore delle credenziali memorizzerà più credenziali, che è quello che volevo davvero.

Ho trovato questa gemma molto utile: sshwitch

https://github.com/agush22/sshwitch
http://rubygems.org/gems/sshwitch

Aiuta a cambiare i tasti SSH. Ricorda di eseguire prima il backup di tutto!

Inoltre, per assicurarmi che gli commit abbiano l'indirizzo email corretto associato, ho fatto in modo che il file ~ / .gitconfig avesse l'indirizzo email corretto.

Oltre a creare più chiavi SSH per più account, puoi anche considerare di aggiungere collaboratori a ciascun progetto utilizzando le stesse e-mail dell'account e archiviare la password in modo permanente.

#this store the password permanently
$ git config --global credential.helper wincred

Ho impostato più account con e-mail diverse, quindi ho inserito lo stesso utente e la stessa e-mail su ciascun account di uno dei collaboratori. In questo modo posso accedere a tutti gli account senza aggiungere la chiave SSH o passare a un altro nome utente ed e-mail per l'autenticazione.

L'approccio più semplice e diretto (IMHO): nessun file di configurazione, non troppa seccatura

Basta creare un altro tasto SSH.

Supponiamo che tu abbia un nuovo account GitHub di lavoro, creane una nuova chiave:

sh-keygen -t rsa -C "email@work_mail.com" -f "id_rsa_work_user1"`

Ora dovresti avere quello vecchio e quello nuovo, per vederli, esegui:

ls -al ~/.ssh

È necessario eseguire quanto sopra solo una volta.

Da ora in poi, ogni volta che vuoi passare da uno all'altro, corri:

ssh-add -D
ssh-add ~/.ssh/id_rsa_work_user1 #make to use this without the suffix .pub

Per passare al vecchio, esegui di nuovo:

 ssh-add -D
 ssh-add ~/.ssh/<previous id_rsa>

un altro modo più semplice è usare più app desktop, come quello che sto facendo, usando l'account A sul desktop Github, mentre usando l'account B su Github Kraken

IntelliJ Idea ha il supporto integrato di questo https://www.jetbrains.com/help/idea/github.html#da8d32ae

Nel caso in cui non si desideri incasinare il ~/.ssh/configfile menzionato qui, è possibile invece eseguirlo git config core.sshCommand "ssh -i ~/.ssh/custom_id_rsa"nel repository in cui si desidera eseguire il commit da un altro account.

Il resto della configurazione è lo stesso:

1. Crea una nuova chiave SSH per il secondo account con ssh-keygen -t rsa -f ~/.ssh -f ~/.ssh/custom_id_rsa

2. Accedi a github con l'altro tuo account, vai su https://github.com/settings/keys e incolla il contenuto di~/.ssh/custom_id_rsa.pub

3. Assicurati di utilizzare SSH anziché HTTPS come URL remoto: git remote set-url origin git@github.com:upstream_project_teamname/upstream_project.git

Non è necessario mantenere due account diversi per personale e lavoro. In effetti, Github ti consiglia di mantenere un unico account e ti aiuta a unire entrambi.

Segui il link qui sotto per unire se decidi che non è necessario mantenere più account.

https://help.github.com/articles/merging-multiple-user-accounts/

A differenza di altre risposte, dove è necessario seguire alcuni passaggi per utilizzare due diversi account github dalla stessa macchina, per me ha funzionato in due passaggi .

Hai solo bisogno di:

1) generare una coppia di chiavi SSH pubbliche e private per ciascun account in ~/.sshposizione con nomi diversi e

2) aggiungere le chiavi pubbliche generate al rispettivo account in Settings>> SSH and GPG keys>>New SSH Key .

Per generare le coppie di chiavi pubbliche e private SSH, utilizzare il comando seguente:

cd ~/.ssh
ssh-keygen -t rsa -C "email@work.com" -f "id_rsa_WORK"
ssh-keygen -t rsa -C "email@gmail.com" -f "id_rsa_PERSONAL"

Come risultato di comandi di cui sopra, id_rsa_WORKe id_rsa_WORK.pubfile verranno creati per il vostro lavoro di conto (ex - git.work.com) ed id_rsa_PERSONALe id_rsa_PERSONAL.pubverrà creato per il vostro personale account (ex - github.com).

Una volta creato, copia il contenuto da ciascun *.pubfile public ( ) ed esegui il passaggio 2 per ciascun account.

PS : Non è necessario creare una voce host per ciascun account git sotto ~/.ssh/configfile come indicato in altre risposte, se il nome host dei tuoi due account è diverso.

Se hai WSL installato, puoi avere due account Git separati: uno su WSL e uno su Windows.

Dovresti e non devi spingere al progetto con alcune credenziali comuni. Una volta avviato su una nuova macchina, attenersi alla seguente procedura per configurare e utilizzare correttamente le credenziali di Gitlab:

• creare le chiavi ssh pubiche / private sulla macchina
• copia incolla la chiave pubblica nell'interfaccia dell'interfaccia utente gitlab / github (chiunque suggerisca come fare tramite la linea cmd ottiene una birra gratis ...)
• assicurati di clonare il repository tramite git e non l'URL http
• imposta l'alias git per evitare la costante digitazione dello stesso prefisso al comando git
• durante git commit utilizzare SEMPRE i flag autore e e-mail
• usa git normalmente lo faresti

Tutto questo come segue:

 # create the public / private key credentials on that specific machine
 ssh-keygen -t rsa -b 4096 -C "<<you>>@org.net" -f ~/.ssh/id_rsa.<<you>>.`hostname -s`

 # setup your public key in the gitlab ui 
 cat ~/.ssh/id_rsa.<<you>>.`hostname -s`

 # make sure you clone the repo via the git and not http url
 git clone git@git.in.org.net:org/some-repo.git

 # set the git alias to avoid constant typing of the repeating prefix to the git cmd
 alias git='GIT_SSH_COMMAND="ssh -i ~/.ssh/id_rsa.<<you>>.`hostname -s`" git'

 # during git commit ALWAYS use the author and e-mail flags
 git add --all ; git commit -nm "$git_msg" --author "YourFirstName YourLastName <you@phz.fi>"

 # use git as normal
 git fetch --all; git pull --all 

1. Passare alla directory in cui si desidera inviare le modifiche a un altro account GitHub.

2. Crea una nuova chiave SSH nel tuo terminale / riga di comando.

   ssh-keygen -t rsa -C “il tuo indirizzo e-mail”

3. Verrà quindi mostrato:

   Generazione di coppie di chiavi rsa pubbliche / private. Inserisci il file in cui salvare la chiave (/home/your_username/.ssh/id_rsa):

Copia e incolla il percorso seguito da un nome identificabile per il file:

/home/your_username/.ssh/id_rsa_personal

4) Ti chiederà quindi quanto segue:

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

5) Ora puoi digitare il seguente comando per vedere tutte le chiavi SSH che hai sul tuo computer locale:

ls -al ~/.ssh

Dovresti essere in grado di vedere il tuo nuovo file di chiavi SSH. Come puoi vedere nel mio, ho sia id_rsa_test che 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) Successivamente è necessario copiare la chiave SSH che è memorizzata nel file id_rsa_personal.pub. Puoi aprirlo nell'editor di testo che preferisci. Attualmente sto usando Atom, quindi ho aperto il file usando il seguente comando:

atom ~/.ssh/id_rsa_personal.pub

Otterrai quindi qualcosa di simile a questo:

ssh-rsa AAB3HKJLKC1yc2EAAAADAQABAAABAQCgU5 + ELtwsKkmcoeF3hNd7d6CjW + dWut83R / Dc01E / YzLc5ZFri18doOwuQoeXpmHVDXQWWHMQWQrcxc

7) Copia questo e vai al tuo account GitHub → Impostazioni → Chiavi SSH e GPG 8) Fai clic su Nuova chiave SSH. Copia la chiave, assegnagli un titolo e aggiungila. 9) Aggiungi chiave dal terminale

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

10) Configura utente e password.

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

11) Siamo pronti a impegnarci e spingere ora.

git init
git add .
git commit 
git push

Se hai creato o clonato un altro repository e non sei stato in grado di estrarre origino upstreamaggiungere la chiave ssh in quella directory usando il seguente comando ha funzionato.

Questo è l'errore che stavo arrivando qui:

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.

Ho usato il seguente comando, questo funziona:

ssh-add ~/.ssh/id_rsa_YOUR_COMPANY_NAME