Mehrere Github-Konten auf demselben Computer?

HTTPS verwenden:

Ändern Sie die Remote-URL in https:

git remote set-url Origin https://[email protected]/USERNAME/PROJECTNAME.git

und du bist gut zu gehen:

git Push

Um sicherzustellen, dass die Commits als von USERNAME ausgeführt angezeigt werden, können Sie auch für dieses Projekt user.name und user.email einrichten:

git config user.name USERNAME
git config user.email [email protected]

In Form kommen

Um ein Git-Repo unter einem separaten Github/Bitbucket/Was auch immer-Konto zu verwalten, müssen Sie lediglich einen neuen SSH-Schlüssel generieren.

Aber bevor wir beginnen können, Repos mit Ihrer zweiten Identität zu pushen/ziehen, müssen wir Sie in Form bringen - Nehmen wir an, Ihr System ist mit einem typischen Schlüsselpaar id_rsa Und id_rsa.pub Eingerichtet. Im Moment sieht Ihr tree ~/.ssh So aus

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

Nennen Sie zuerst dieses Schlüsselpaar, und fügen Sie einen beschreibenden Namen hinzu, damit Sie sich merken können, welcher Schlüssel für welchen Benutzer/welche Fernbedienung verwendet wird

# 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

Als nächstes wollen wir ein neues Schlüsselpaar generieren - hier werde ich den neuen Schlüssel benennen github-otheruser

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

Wenn wir uns nun tree ~/.ssh Ansehen, sehen wir

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

Als nächstes müssen wir eine ~/.ssh/config - Datei einrichten, die unsere Schlüsselkonfigurationen definiert. Wir erstellen es mit den richtigen Lese-/Schreibberechtigungen für den Eigentümer

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

Öffnen Sie das mit Ihrem Lieblingseditor und fügen Sie den folgenden Inhalt hinzu

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

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

Vermutlich haben Sie einige Repos, die Ihrer primären Github-Identität zugeordnet sind. Aus diesem Grund ist "default" github.com Host so eingerichtet, dass Ihr mainuser Schlüssel verwendet wird. Wenn Sie nicht möchten, dass ein Konto einem anderen vorgezogen wird, zeige ich Ihnen, wie Sie vorhandene Repos auf Ihrem System aktualisieren, um eine aktualisierte SSH-Konfiguration zu verwenden.

Füge deinen neuen SSH-Schlüssel zu github hinzu

Gehen Sie zu github.com/settings/keys , um Ihren neuen öffentlichen Schlüssel hinzuzufügen

Sie können den Inhalt des öffentlichen Schlüssels mit folgendem Befehl abrufen: Kopieren/Einfügen in Github

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

Jetzt ist Ihre neue Benutzeridentität vollständig eingerichtet. Nachfolgend wird die Verwendung der Benutzeridentität beschrieben.

Dinge erledigen: ein Repo klonen

Wie kommt das zusammen, um mit git und github zu arbeiten? Nun, weil Sie kein Huhn ohne und Ei haben können, schauen wir uns das Klonen eines vorhandenen Repos an. Diese Situation kann auf Sie zutreffen, wenn Sie ein neues Github-Konto für Ihren Arbeitsplatz haben und zu einem Unternehmensprojekt hinzugefügt wurden.

Angenommen, github.com/someorg/somerepo Existiert bereits und Sie wurden hinzugefügt - das Klonen ist so einfach wie

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

Dieser fettgedruckte Teil muss entspricht dem Namen Host, den wir in Ihrem ~/.ssh/config Eingegeben haben. Datei. Das verbindet git korrekt mit dem entsprechenden IdentityFile und authentifiziert dich korrekt mit github

Dinge erledigen: ein neues Repo erstellen

Nun, da Sie kein Huhn ohne und Ei haben können, werden wir versuchen, ein neues Repo auf Ihrem sekundären Konto zu veröffentlichen. Diese Situation gilt für Benutzer, die mit ihrem sekundären Github-Konto Neu Inhalte erstellen.

Nehmen wir an, Sie haben bereits ein wenig vor Ort gearbeitet und können jetzt Push to Github ausführen. Sie können mir folgen, wenn Sie möchten

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

Konfigurieren Sie dieses Repo nun so, dass es Ihre Identität verwendet

$ git config user.name "Mister Manager"
$ git config user.email "[email protected]"

Machen Sie jetzt Ihr erstes Commit

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

Überprüfen Sie das Commit, um festzustellen, ob Ihre neue Identität mit Git-Protokoll verwendet wurde

$ git log --pretty="%H %an <%ae>"
f397a7cfbf55d44ffdf87aa24974f0a5001e1921 Mister Manager <[email protected]>

Okay, Zeit zum Push to Github! Da github noch nichts über unser neues Repo weiß, gehe zuerst zu github.com/new und erstelle dein neues Repo - benenne es somerepo

Um Ihr Repo so zu konfigurieren, dass es mit der richtigen Identität/den richtigen Anmeldeinformationen mit Github "spricht", haben wir eine Fernbedienung hinzugefügt. Angenommen, Ihr github-Benutzername für Ihr neues Konto lautet someuser ...

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

Dieser fettgedruckte Teil ist absolut kritisch und muss muss mit dem Host übereinstimmen, das wir in Ihrem ~/.ssh/config Datei

Zuletzt schieben Sie das Repo

$ git Push Origin master

Aktualisieren Sie ein vorhandenes Repo, um eine neue SSH-Konfiguration zu verwenden

Angenommen, Sie haben bereits ein Repo geklont, möchten aber jetzt eine neue SSH-Konfiguration verwenden. Im obigen Beispiel haben wir Ihre vorhandenen Repos auf dem neuesten Stand gehalten, indem wir Ihr vorheriges Schlüsselpaar id_rsa/id_rsa.pubHost github.com In Ihrer SSH-Konfigurationsdatei zugewiesen haben. Daran ist nichts auszusetzen, aber ich habe jetzt mindestens 5 Github-Konfigurationen und ich stelle mir nicht gerne eine davon als "Standard" -Konfiguration vor - ich würde lieber jede explizit behandeln.

Bevor wir das hatten

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

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

Also werden wir das jetzt aktualisieren (Änderungen in fett )

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

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

Dies bedeutet jedoch, dass ein vorhandenes Repo mit einer github.com - Fernbedienung nicht mehr mit dieser Identitätsdatei funktioniert. Aber keine Sorge, es ist eine einfache Lösung.

Um ein vorhandenes Repo zu aktualisieren und Ihre neue SSH-Konfiguration zu verwenden, öffnen Sie einfach die Git-Konfigurationsdatei des Repos und aktualisieren Sie die URL!

$ cd existingrepo
$ nano .git/config

Aktualisieren Sie das entfernte Ursprungsfeld (Änderungen in Fettdruck )

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

Das ist es. Jetzt können Sie Push/pull nach Herzenslust

SSH-Schlüsseldateiberechtigungen

Wenn Sie Probleme damit haben, dass Ihre öffentlichen Schlüssel nicht richtig funktionieren, ist SSH in Bezug auf das Dateiberechtigungen , das in Ihrem ~/.ssh - Verzeichnis und den entsprechenden Schlüsseldateien zulässig ist, recht streng

Als Faustregel gilt, dass alle Verzeichnisse 700 Und alle Dateien 600 Sein sollten - dies bedeutet, dass sie nur vom Eigentümer gelesen/geschrieben werden können - keine andere Gruppe/Benutzer kann sie lesen/schreiben

$ 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

Wie verwalte ich meine SSH-Schlüssel?

Ich verwalte separate SSH-Schlüssel für jeden Host, zu dem ich eine Verbindung herstelle, so dass ich, wenn ein Schlüssel jemals kompromittiert wird, die Schlüssel nicht an jedem anderen Ort aktualisieren muss, an dem ich diesen Schlüssel verwendet habe. Dies ist so, als Sie von Adobe die Benachrichtigung erhalten, dass 150 Millionen der Benutzerinformationen gestohlen wurden. Jetzt müssen Sie diese Kreditkarte kündigen und jeden Dienst aktualisieren, der davon abhängt. Was für ein Ärgernis.

So sieht mein ~/.ssh - Verzeichnis aus: Ich habe einen .pem - Schlüssel für jeden Benutzer in einem Ordner für jede Domäne, mit der ich mich verbinde. Ich benutze die .pem - Schlüssel, um nur die one Datei pro Schlüssel zu benötigen.

$ 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

Und hier ist meine entsprechende /.ssh/config - offensichtlich ist das Github-Zeug für die Beantwortung dieser Frage über Github relevant, aber diese Antwort soll Sie mit dem Wissen ausstatten, Ihre SSH-Identitäten auf einer beliebigen Anzahl von Diensten/Maschinen zu verwalten.

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

Abrufen Ihres öffentlichen SSH-Schlüssels von einem PEM-Schlüssel

Oben ist dir aufgefallen, dass ich nur eine Datei für jeden Schlüssel habe. Wenn ich einen öffentlichen Schlüssel bereitstellen muss, generiere er einfach nach Bedarf.

Wenn github Sie nach Ihrem öffentlichen ssh-Schlüssel fragt, führen Sie diesen Befehl aus, um den öffentlichen Schlüssel nach stdout auszugeben - kopieren/einfügen, wo erforderlich

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

Beachten Sie, dass dies auch derselbe Vorgang ist, den ich zum Hinzufügen meines Schlüssels zu einem Remote-Computer verwende. Der Wert ssh-rsa AAAA... Wird in die Datei ~/.ssh/authorized_keys Der Fernbedienung kopiert

Konvertieren Ihrer id_rsa/id_rsa.pub - Schlüsselpaare in das PEM-Format

Sie möchten also Ihre Schlüsseldateien zähmen und einige Dateisystemprobleme reduzieren? Das Umwandeln Ihres Schlüsselpaares in ein single PEM ist einfach

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

Oder wir folgen unseren obigen Beispielen und benennen id_rsa -> github-mainuser Und id_rsa.pub -> github-mainuser.pub Um - also

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

Um sicherzugehen, dass wir dies korrekt konvertiert haben, müssen Sie sicherstellen, dass der öffentliche Schlüssel generiert mit Ihrem alten öffentlichen Schlüssel übereinstimmt

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

Nachdem Sie Ihre github-mainuser.pem - Datei haben, können Sie Ihre alten github-mainuser - und github-mainuser.pub - Dateien sicher löschen - nur die PEM-Datei ist erforderlich; generiere einfach den öffentlichen Schlüssel, wann immer du ihn brauchst ^ _ ^

PEM-Schlüssel von Grund auf neu erstellen

Sie müssen das private/öffentliche Schlüsselpaar nicht erstellen und then in einen einzelnen PEM-Schlüssel konvertieren. Sie können den PEM-Schlüssel direkt erstellen.

Erstellen wir einen newuser.pem

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

Der Erhalt des öffentlichen SSH-Schlüssels ist derselbe

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

Durch Erstellen verschiedener Host-Aliasnamen für github.com in ~/.ssh/config, Und indem jedem Host-Alias ​​ein eigener ssh-Schlüssel zugewiesen wird, können Sie problemlos mehrere Github-Konten ohne Verwirrung verwenden . Das liegt daran, dass github .com unterscheidet sich nicht nach dem Benutzer, der immer nur git, ist, sondern nach dem ssh-Schlüssel, den Sie zum Verbinden verwendet haben . Konfigurieren Sie Ihre Remote-Ursprünge mithilfe Ihrer eigenen Host-Aliasnamen. "

Die obige Zusammenfassung basiert auf den Kommentaren des nachstehenden Blogposts.

Ich habe diese Erklärung am deutlichsten gefunden. Und es funktioniert für mich, zumindest ab April 2012.

http://net.tutsplus.com/tutorials/tools-und-tipps/wie-zu-arbeiten-mit-github-und-multiple-accounts/

Die Angaben unter http://net.tutsplus.com/tutorials/tools-and-tips/how-to-work-with-github-and-multiple-accounts/ , die von mishaba verlinkt sind, funktionieren sehr gut für mich .

Von dieser Seite:

$ touch ~/.ssh/config

Bearbeiten Sie diese Datei dann so, dass sie ungefähr so ​​aussieht (ein Eintrag pro Konto):

#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

Ich verwende Shell-Skripte, um auf das Konto zu wechseln, das ich "aktiv" sein möchte. Im Wesentlichen fangen Sie mit einem Neustart an, lassen ein Konto ordnungsgemäß konfiguriert werden und arbeiten, dann verschieben Sie diese Dateien auf einen Namen mit dem richtigen Präfix. Von da an können Sie den Befehl "github" oder "gitxyz" verwenden, um zu wechseln:

# 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 "[email protected]<company>.com"
git config --global github.user "dhoerl"        
git config --global github.token "whatever_it_is"

ssh-add -D

Ich hatte viel Glück damit. Ich habe auch ein Laufskript in Xcode (für Sie Mac-Benutzer) erstellt, damit mein Projekt nicht erstellt werden kann, wenn ich nicht die richtige Einstellung hatte (da es git verwendet):

Skript nach Abhängigkeiten ausführen (mit/bin/ksh als Shell):

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

BEARBEITEN: Tests zum Vorhandensein neuer Dateien hinzugefügt und alte Dateien nach/tmp kopiert, um den Kommentar von @naomik unten zu adressieren.

Vielen Dank an user1107028:

HTTPS verwenden:

Ändern Sie die Remote-URL in https:

git remote set-url Origin https: //[email protected]/USERNAME/PROJECTNAME.git und Sie sind gut gehen:

git Push

Ich fand dies am besten, wenn ich mehrere Github-Konten verwende. Ich kann nicht nur einen Account verwenden, es ist einfach nicht möglich und ich konnte SSH nicht dazu bringen, sich zu benehmen, egal was ich getan habe. Ich habe die Antwort abgelehnt, aber ich habe nicht genug Punkte - ich wollte diese einfache Problemumgehung für diejenigen wie mich, die eine saubere, einfache Lösung benötigen, anerkennen. Es hat beim ersten Mal funktioniert und mir Stunden erspart, mehr zu kämpfen.

• Gehe zu ~/.ssh
• Erstellen Sie eine Datei mit dem Namen config (ohne Erweiterung)

• Öffnen Sie die Konfigurationsdatei und fügen Sie die folgenden Codes hinzu. (je nach Konto ändern)

  1. Konto 1

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

  2. Konto 2

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

  3. Konto 3

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

• Fügen Sie die Remote-URL wie folgt hinzu

  1. Konto 1

     git remote add Origin [email protected]_1:group_name/repo_name.git
     

  2. Konto 2

     git remote add Origin [email protected]:group_name/repo_name.git
     

  3. Konto 3

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

Stellen Sie sicher, dass die IdentityFile-Namen mit den bei der ssh-Schlüsselerstellung erstellten identisch sind.

Diese Antwort ist für Anfänger (Nichtgit-Gurus) . Ich hatte vor kurzem dieses Problem und vielleicht ist es nur ich, aber die meisten Antworten schienen ein ziemlich vorausschauendes Verständnis von GIT zu erfordern. Nachdem Sie mehrere Stack-Overflow-Antworten einschließlich dieses Threads gelesen haben, müssen Sie die GitHub-Konten problemlos wechseln (z. B. zwei GitHub-Konten, github.com/personal und gitHub.com/work)): 

1. Vorhandene SSH-Schlüssel prüfen:Terminal öffnen und diesen Befehl ausführen, um vorhandene SSH-Schlüssel anzuzeigen/aufzulisten ls -al ~/.ssh 
   dateien mit der Erweiterung .pub sind Ihre SSH-Schlüssel. Sie sollten also zwei für die Konten personal und work haben. Wenn es nur einen oder keinen gibt, ist es an der Zeit andere zu generieren, dies zu überspringen.
   
   - Generieren des SSH-Schlüssels: Melden Sie sich bei github an (entweder im persönlichen Bereich oder im Arbeitsbereich), navigieren Sie zu Settings und kopieren Sie die zugehörige E-Mail.
   gehen Sie jetzt zurück zu Terminal und führen Sie ssh-keygen -t rsa -C "the copied email" aus. Sie sehen:
   
   Öffentliches/privates RSA-Schlüsselpaar generieren.
   Geben Sie die Datei ein, in der der Schlüssel gespeichert werden soll (/.../.ssh/id_rsa):
   
   id_rsa ist der Standardname für den in Kürze zu generierenden SSH-Schlüssel. Kopieren Sie daher den Pfad und benennen Sie den Standardnamen um, z. /.../.ssh/id_rsa_work wenn für Arbeitskonto generiert wird. Geben Sie ein Kennwort ein, oder geben Sie einfach die Eingaben ein, um sie zu ignorieren. Sie lesen so etwas wie . Das Zufallsbild der Taste lautet: und das Bild. erledigt.
   Wiederholen Sie diesen Schritt noch einmal für Ihr zweites Github-Konto. Stellen Sie sicher, dass Sie die richtige E-Mail-Adresse und einen anderen ssh-Schlüsselnamen verwenden (z. B. id_rsa_personal), um ein Überschreiben zu vermeiden.
   Zu diesem Zeitpunkt sollten Sie zwei ssh-Schlüssel sehen, wenn Sie ls -al ~/.ssh erneut ausführen.
2. Ordnen Sie den ssh-Schlüssel dem gitHub-Konto zu: Als nächsten Schritt kopieren Sie einen der ssh-Schlüssel. Führen Sie diesen Befehl aus, ersetzen Sie jedoch Ihren eigenen ssh-Schlüsselnamen: pbcopy < ~/.ssh/id_rsa_work.pub, ersetzen Sie id_rsa_work.pub durch das, was Sie als Ihren bezeichnet haben.
   Nun, da unser ssh-Schlüssel in die Zwischenablage kopiert wurde, kehren Sie zu github account zurück. [Stellen Sie sicher, dass Sie beim arbeitskonto angemeldet sind, wenn der von Ihnen kopierte ssh-Schlüssel id_rsa_work ist] und navigieren Sie zu
   Einstellungen - SSH- und GPG-Tasten und klicken Sie auf die Schaltfläche Neue SSH-Taste (nicht Neue GPG-Taste btw: D)
   Geben Sie einen Titel für diesen Schlüssel ein, fügen Sie den Schlüssel ein und klicken Sie auf SSH-Schlüssel hinzufügen. Sie haben jetzt entweder den SSH-Schlüssel erfolgreich hinzugefügt oder festgestellt, dass es die ganze Zeit über dort war, was in Ordnung ist (oder Sie haben einen Fehler erhalten, weil Sie Neuer GPG-Schlüssel anstelle von Neuer SSH-Schlüssel: D) ausgewählt haben. 
3. SSH-Schlüssel mit gitHub-Konto verknüpfen : Wiederholen Sie den obigen Schritt für Ihr zweites Konto.

4. Bearbeiten Sie die globale Git-Konfiguration: Der letzte Schritt besteht darin, sicherzustellen, dass die globale Konfigurationsdatei alle Github-Konten kennt (sozusagen).
   Führen Sie git config --global --edit aus, um diese globale Datei zu bearbeiten. Wenn dies vim öffnet und Sie nicht wissen, wie sie verwendet wird, drücken Sie i, um den Einfügemodus zu aktivieren, bearbeiten Sie die Datei wie unten beschrieben und drücken Sie esc gefolgt von :wq, um den Einfügemodus zu beenden: 

   [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

Fertig! Wenn Sie nun versuchen, von einem Repo zu pushen oder zu ziehen, werden Sie gefragt, welches GitHub-Konto mit diesem Repo verknüpft werden soll, und es muss nur einmal gefragt werden. Die lokale Konfiguration speichert diesen Link und nicht die globale Konfiguration, damit Sie arbeiten können auf verschiedenen Repos, die mit verschiedenen Konten verknüpft sind, ohne jedes Mal die globale Konfiguration bearbeiten zu müssen. 

Einfachere und einfache Lösung, um Verwirrungen zu vermeiden.

Für Windows-Benutzer zur Verwendung mehrerer oder verschiedener Git-Konten für verschiedene Projekte.

Gehen Sie folgendermaßen vor: Gehen Sie zur Systemsteuerung und suchen Sie nach Credential Manager . Gehen Sie dann zu Credential Manager -> Windows Credentials

Entfernen Sie nun den Knoten git: https // github.com unter Überschrift "Generic Credentials"

Dadurch werden die aktuellen Anmeldeinformationen entfernt. Jetzt können Sie ein beliebiges Projekt über git pull hinzufügen. Dabei werden Benutzername und Kennwort abgefragt. 

Wenn Sie Probleme mit einem anderen Konto haben, führen Sie denselben Vorgang aus.

Vielen Dank

siehe Bild

Sie können nicht nur mehrere SSH-Schlüssel für mehrere Konten erstellen, sondern auch Mitarbeiter für jedes Projekt mit denselben E-Mail-Konten hinzufügen und das Kennwort dauerhaft speichern.

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

Ich habe mehrere Konten mit verschiedenen E-Mails eingerichtet, dann den gleichen Benutzer und die gleiche E-Mail-Adresse für jedes Konto als Mitbearbeiter angeben. Auf diese Weise kann ich auf alle Konten zugreifen, ohne den SSH-Schlüssel hinzuzufügen oder zu einem anderen Benutzernamen und ohne E-Mail zur Authentifizierung zu wechseln.

Ich fand dieses Juwel sehr nützlich: sshwitch

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

Es hilft, SSH-Schlüssel auszutauschen. Denken Sie daran, zuerst alles zu sichern!

Um sicherzustellen, dass für Commits die richtige E-Mail-Adresse angegeben ist, habe ich sichergestellt, dass die Datei ~/.gitconfig die richtige E-Mail-Adresse hat.

Im Gegensatz zu anderen Antworten, bei denen Sie einige Schritte ausführen müssen , um zwei verschiedene Github Konto von der gleichen Maschine, bei mir funktionierte es in zwei Schritten .

Sie müssen nur:

1) Generieren Sie ein öffentliches und ein privates SSH-Schlüsselpaar für jedes Konto unter ~/.ssh Mit unterschiedlichen Namen und

2) Fügen Sie die generierten öffentlichen Schlüssel dem jeweiligen Konto unter Settings >> SSH and GPG keys >> New SSH Key.

Verwenden Sie zum Generieren der öffentlichen und privaten SSH-Schlüsselpaare den folgenden Befehl:

cd ~/.ssh
ssh-keygen -t rsa -C "[email protected]" -f "id_rsa_WORK"
ssh-keygen -t rsa -C "[email protected]" -f "id_rsa_PERSONAL"

Infolge der obigen Befehle werden id_rsa_WORK - und id_rsa_WORK.pub - Dateien für Ihr Arbeitskonto erstellt (Beispiel) .work.com) und id_rsa_PERSONAL und id_rsa_PERSONAL.pub werden für Ihr persönliches Konto (ex - github.com) erstellt ).

Kopieren Sie nach der Erstellung den Inhalt aus jeder öffentlichen Datei (*.pub) Und führen Sie Schritt 2 für jedes Konto aus.

[~ # ~] ps [~ # ~] : Es ist nicht erforderlich, einen Host-Eintrag für jedes Git-Konto in der Datei ~/.ssh/config vorzunehmen Wie in anderen Antworten erwähnt, wenn der Hostname Ihrer beiden Konten unterschiedlich ist.

Sie müssen nicht zwei verschiedene Konten für Personal und Arbeit führen. Tatsächlich empfiehlt Github, dass Sie ein einzelnes Konto verwalten und Ihnen dabei helfen, beide zusammenzuführen. 

Folgen Sie dem untenstehenden Link, um die Zusammenführung durchzuführen, wenn Sie nicht mehrere Konten verwalten müssen. 

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

eine andere einfachere Methode ist die Verwendung mehrerer Desktop-Apps, wie z. B. das, was ich mache, Konto A auf dem Github-Desktop und Konto B auf Github Kraken

Der einfachste und unkomplizierteste Ansatz (IMHO) - keine Konfigurationsdateien, nicht zu viel Aufwand 

Erstellen Sie einfach einen weiteren SSH-Schlüssel.

Nehmen wir an, Sie haben ein neues GitHub-Konto, erstellen Sie einfach einen neuen Schlüssel dafür:

sh-keygen -t rsa -C "[email protected]_mail.com" -f "id_rsa_work_user1"`

Jetzt sollten Sie die alte und die neue haben, um sie zu sehen, laufen Sie:

ls -al ~/.ssh

Sie müssen das obige nur einmal ausführen.

Führen Sie von nun an jedes Mal, wenn Sie zwischen den beiden wechseln möchten, Folgendes aus:

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

Um zum alten zu wechseln, führen Sie den Vorgang erneut aus:

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

ich habe dies gerade für Windows herausgefunden und die Berechtigungsnachweise für jedes Repo verwendet:

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

Das Format des Berechtigungsnachweises. https://github.com . teilt dem Helper für Berechtigungsnachweise die URL für den Berechtigungsnachweis mit. Der 'useHttpPath' teilt dem Berechtigungsmanager mit, den Pfad für den Berechtigungsnachweis zu verwenden. Wenn useHttpPath weggelassen wird, speichert der Anmeldeinformationsmanager einen Berechtigungsnachweis für https://github.com . Wenn es enthalten ist, speichert der Anmeldeinformationsmanager mehrere Anmeldeinformationen, was ich wirklich wollte.

Wenn Sie WSL installiert haben, können Sie zwei separate Git-Konten einrichten - einen für WSL und einen für Windows.