Mehrere Github-Konten auf demselben Computer?

Ich versuche, sowohl meine eigentlichen "Arbeits" -Repos als auch meine persönlichen Repos auf dem Git-Hub von meinem Computer aus zu bearbeiten.

Das Arbeitskonto wurde zuerst eingerichtet und alles funktioniert einwandfrei.

Mein persönliches Konto kann jedoch nicht auf mein persönliches Repo übertragen werden, das unter einem anderen Konto / einer anderen E-Mail-Adresse eingerichtet ist.

Ich habe versucht, meinen Arbeitsschlüssel in mein persönliches Konto zu kopieren, aber das wirft einen Fehler auf, da ein Schlüssel natürlich nur an ein Konto angehängt werden kann.

Wie kann ich von ihren jeweiligen Github-Anmeldeinformationen zu und von beiden Konten pushen / ziehen?

Sie müssen lediglich Ihr SSH-Setup mit mehreren SSH-Schlüsselpaaren konfigurieren.

• Dieser Link ist leicht zu folgen (Danke Eric): http://code.tutsplus.com/tutorials/quick-tip-how-to-work-with-github-and-multiple-accounts--net-22574

• Generieren von SSH-Schlüsseln (Win / msysgit) https://help.github.com/articles/generating-an-ssh-key/

Wenn Sie mit mehreren Repositorys mit unterschiedlichen Personas arbeiten, müssen Sie außerdem sicherstellen, dass in Ihren einzelnen Repositorys die Benutzereinstellungen entsprechend überschrieben werden:

Festlegen des Benutzernamens, der E-Mail-Adresse und des GitHub-Tokens - Überschreiben der Einstellungen für einzelne Repos https://help.github.com/articles/setting-your-commit-email-address-in-git/

Hoffe das hilft.

Hinweis: Einige von Ihnen benötigen möglicherweise unterschiedliche E-Mails, um für unterschiedliche Repositorys verwendet zu werden. Ab Git 2.13 können Sie die E-Mail auf Verzeichnisbasis festlegen, indem Sie die globale Konfigurationsdatei bearbeiten, die sich ~/.gitconfigunter folgender Bedingung befindet:

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

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

Und dann würde Ihre arbeitsspezifische Konfiguration ~ / work / .gitconfig folgendermaßen aussehen:

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

Vielen Dank an @alexg, dass Sie mich in den Kommentaren darüber informiert haben.

Verwenden Sie HTTPS:

Ändern Sie die Remote-URL in https:

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

und du bist gut zu gehen:

git push

Um sicherzustellen, dass die Commits wie von USERNAME ausgeführt angezeigt werden , können Sie den Benutzernamen und die Benutzer- E- Mail auch für dieses Projekt einrichten :

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

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 / Schieben repos mit dem zweiten Identität ziehen, wir müssen Sie in Form bringen - nehmen wir an , Ihr System - Setup mit einem typischen id_rsaund id_rsa.pubSchlüsselpaar. Im Moment siehst du so tree ~/.sshaus

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

Benennen Sie zunächst dieses Schlüsselpaar. Wenn Sie einen beschreibenden Namen hinzufügen , können Sie sich merken, 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 generieren wir ein neues Schlüsselpaar - hier werde ich den neuen Schlüssel benennengithub-otheruser

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

Wenn wir jetzt schauen, sehen tree ~/.sshwir

$ 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/configDatei einrichten , die unsere Schlüsselkonfigurationen definiert. Wir erstellen es mit den richtigen Lese- / Schreibberechtigungen für Eigentümer

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

Öffnen Sie das mit Ihrem bevorzugten Editor 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 sind einige Repos mit Ihrer primären Github-Identität verknüpft. Aus diesem Grund ist der "Standard" github.com Hostso eingerichtet, dass er Ihren mainuserSchlüssel verwendet. Wenn Sie nicht ein Konto einem anderen vorziehen möchten, zeige ich Ihnen, wie Sie vorhandene Repos auf Ihrem System aktualisieren, um eine aktualisierte SSH-Konfiguration zu verwenden.

Fügen Sie Ihren 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 abrufen, indem Sie ihn in github kopieren / einfügen

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

Jetzt ist Ihre neue Benutzeridentität vollständig eingerichtet. Im Folgenden zeigen wir Ihnen, wie Sie sie verwenden.

Dinge erledigen: ein Repo klonen

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

Nehmen wir an, es github.com/someorg/somerepoexistiert bereits und Sie wurden hinzugefügt - das Klonen ist so einfach wie

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

Dieser fettgedruckte Teil muss mit dem HostNamen übereinstimmen, den wir in Ihrer ~/.ssh/configDatei eingerichtet haben. Das verbindet git richtig mit dem entsprechenden IdentityFileund authentifiziert dich richtig mit github

Dinge erledigen: ein neues Repo erstellen

Nun, da Sie kein Huhn ohne 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 neue Inhalte erstellen.

Nehmen wir an, Sie haben bereits ein wenig vor Ort gearbeitet und sind jetzt bereit, auf Github umzusteigen. Sie können mir folgen, wenn Sie möchten

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

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

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

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 mithilfe des Git-Protokolls verwendet wurde

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

Okay, Zeit zum Github zu drängen! Da github noch nichts über unser neues Repo weiß, gehen Sie zuerst zu github.com/new und erstellen Sie Ihr neues Repo - nennen Sie 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 mit dem übereinstimmen, den Hostwir in Ihrer ~/.ssh/configDatei definiert haben

Zuletzt das Repo drücken

$ 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 id_rsa/ id_rsa.pubSchlüsselpaar Host github.comin Ihrer SSH-Konfigurationsdatei zugewiesen haben. Daran ist nichts auszusetzen, aber ich habe jetzt mindestens 5 Github-Konfigurationen und ich mag es nicht, eine davon als "Standard" -Konfiguration zu betrachten - ich würde lieber jede explizit beschreiben.

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 Fettdruck )

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

Dies bedeutet jedoch, dass jetzt jedes vorhandene Repo mit einer github.comFernbedienung 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 Feld für den Remote-Ursprung (Ä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/ pullnach Herzenslust

Berechtigungen für SSH-Schlüsseldateien

Wenn Sie Probleme mit Ihren öffentlichen Schlüsseln haben, die nicht richtig funktionieren, sind die Dateiberechtigungen, die für Ihr ~/.sshVerzeichnis und die entsprechenden Schlüsseldateien zulässig sind , bei SSH recht streng

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

$ 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, mit dem ich eine Verbindung herstelle. Wenn also ein Schlüssel jemals kompromittiert wird, muss ich die Schlüssel nicht an jedem anderen Ort aktualisieren, an dem ich diesen Schlüssel verwendet habe. Dies ist wie wenn Sie die Benachrichtigung von Adobe erhalten, dass 150 Millionen der Benutzerinformationen gestohlen wurden - jetzt müssen Sie diese Kreditkarte stornieren und jeden Dienst aktualisieren, der davon abhängt - was für ein Ärgernis.

So ~/.sshsieht mein Verzeichnis aus: Ich habe einen .pemSchlüssel für jeden Benutzer in einem Ordner für jede Domäne, zu der ich eine Verbindung herstelle. Ich benutze .pemSchlüssel, damit ich nur eine Datei pro Schlüssel brauche .

$ 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/configDatei - natürlich ist das Github-Zeug für die Beantwortung dieser Frage zu 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 haben Sie bemerkt, dass ich nur eine Datei für jeden Schlüssel habe. Wenn ich einen öffentlichen Schlüssel bereitstellen muss, generiere ich ihn einfach nach Bedarf.

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

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

Beachten Sie, dass dies auch der gleiche Vorgang ist, den ich zum Hinzufügen meines Schlüssels zu einem Remotecomputer verwende. Der ssh-rsa AAAA...Wert wird in die ~/.ssh/authorized_keysDatei der Fernbedienung kopiert

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

Sie möchten also Ihre Schlüsseldateien zähmen und die Dateisystem-Cruft reduzieren? Das Konvertieren Ihres Schlüsselpaars in eine einzelne PEM ist einfach

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

Oder wir haben, zusammen mit unseren obigen Beispielen, umbenannt id_rsa -> github-mainuserund id_rsa.pub -> github-mainuser.pub- so

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

Um sicherzustellen, dass wir dies korrekt konvertiert haben, sollten Sie überprüfen, ob der generierte öffentliche Schlüssel 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.pemDatei erstellt haben, können Sie Ihre alten Dateien github-mainuserund github-mainuser.pubDateien sicher löschen. Es ist nur die PEM-Datei erforderlich. Generieren Sie einfach den öffentlichen Schlüssel, wann immer Sie ihn benötigen ^ _ ^

PEM-Schlüssel von Grund auf neu erstellen

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

Lassen Sie uns eine erstellen newuser.pem

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

Das Abrufen des öffentlichen SSH-Schlüssels ist dasselbe

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

Indem Sie in Ihrer ~ / .ssh / config verschiedene Host-Aliase für github.com erstellen und jedem Host-Alias ​​einen eigenen SSH-Schlüssel zuweisen, können Sie problemlos mehrere Github-Konten ohne Verwirrung verwenden. Das liegt daran, dass github.com nicht nach Benutzer unterscheidet, was immer nur git ist, sondern nach dem SSH-Schlüssel, mit dem Sie die Verbindung hergestellt haben. Konfigurieren Sie einfach Ihre Remote-Ursprünge mit Ihren eigenen Host-Aliasen. “

Die obige Zusammenfassung wurde mit freundlicher Genehmigung von Kommentaren im Blog-Beitrag unten erstellt.

Ich habe diese Erklärung am klarsten gefunden. Und es funktioniert bei mir zumindest ab April 2012.

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

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

Von dieser Seite:

$ touch ~/.ssh/config

Bearbeiten Sie diese Datei dann wie folgt (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

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

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

  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 git@gitlab.com-account_1:group_name/repo_name.git
     

  2. Konto 2

     git remote add origin git@gitlab.com-Account2: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 denen übereinstimmen, die Sie während der Generierung des SSH-Schlüssels erstellt haben.

Ich verwende Shell-Skripte, um zu einem Konto zu wechseln, für das ich "aktiv" sein möchte. Im Wesentlichen beginnen Sie mit einem Neuanfang, lassen ein Konto ordnungsgemäß konfigurieren und funktionieren und verschieben diese Dateien dann in einen Namen mit dem richtigen Präfix. Von da an können Sie mit dem Befehl "github" oder "gitxyz" 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 "dhoerl@<company>.com"
git config --global github.user "dhoerl"        
git config --global github.token "whatever_it_is"

ssh-add -D

Ich hatte großes Glück damit. Ich habe auch ein Ausführungsskript in Xcode erstellt (für Sie Mac-Benutzer), damit mein Projekt nur erstellt wird, wenn ich die richtige Einstellung habe (da es git verwendet):

Führen Sie das nach Abhängigkeiten platzierte Skript aus (mit / bin / ksh als Shell):

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

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

Diese Antwort ist für Anfänger (Nicht-Git-Gurus) . Ich hatte vor kurzem dieses Problem und vielleicht bin ich es nur, aber die meisten Antworten schienen ein eher fortgeschrittenes Verständnis von Git zu erfordern. Nachdem ich mehrere Antworten zum Stapelüberlauf einschließlich dieses Threads gelesen habe, sind folgende Schritte erforderlich, um problemlos zwischen GitHub-Konten zu wechseln (z. B. zwei GitHub-Konten, github.com/personal und gitHub.com/work ):

1. Nach vorhandenen SSH-Schlüsseln suchen: Öffnen Sie das Terminal und führen Sie diesen Befehl aus, um vorhandene SSH-Schlüsseldateienls -al ~/.ssh
   mit der Erweiterung.pubanzuzeigen/ aufzulisten.Ihre SSH-Schlüssel sind also Ihre SSH-Schlüssel. Sie sollten also zwei für dieKontenpersonalund habenwork. Wenn es nur eine oder keine gibt, ist es an der Zeit, dies zu generieren.
   
   - Generieren eines SSH-Schlüssels : Melden Sie sich bei Github an (entweder persönlich oder beruflich), navigieren Sie zu Einstellungen und kopieren Sie die zugehörige E-Mail.
   Gehen Sie jetzt zurück zum Terminal und führenssh-keygen -t rsa -C "the copied email"Sie
   
   Folgendes aus
   : Generieren eines öffentlichen / privaten RSA-Schlüsselpaars. Geben Sie die Datei ein, in der der Schlüssel gespeichert werden soll (/.../.ssh/id_rsa):
   
   id_rsa ist der Standardname für den bald zu generierenden SSH-Schlüssel. Kopieren Sie also den Pfad und benennen Sie den Standard um, z /.../.ssh/id_rsa_workbeim Generieren für Arbeitskonto. Geben Sie ein Passwort ein oder geben Sie es einfach ein, um es zu ignorieren. Sie lesen so etwas wie das Randomart-Bild des Schlüssels: 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 (z. B. id_rsa_personal) verwenden, um ein Überschreiben zu vermeiden.
   Zu diesem Zeitpunkt sollten beim ls -al ~/.ssherneuten Ausführen zwei SSH-Schlüssel angezeigt werden.
2. Verknüpfen des SSH-Schlüssels mit dem gitHub-Konto: Der nächste Schritt besteht darin, einen der SSH-Schlüssel zu kopieren, diesen auszuführen, aber Ihren eigenen SSH-Schlüsselnamen zu pbcopy < ~/.ssh/id_rsa_work.pubersetzen : Ersetzen id_rsa_work.pubSie ihn durch Ihren Namen.
   Nachdem unser SSH-Schlüssel in die Zwischenablage kopiert wurde, kehren Sie zum Github-Konto zurück [Stellen Sie sicher, dass Sie beim Arbeitskonto angemeldet sind, wenn der von Ihnen kopierte SSH-Schlüssel verwendet wird id_rsa_work] und navigieren Sie zu
   Einstellungen - SSH- und GPG-Schlüssel und klicken Sie auf die Schaltfläche Neuer SSH-Schlüssel (nicht neuer GPG-Schlüssel übrigens: 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 den SSH-Schlüssel jetzt entweder erfolgreich hinzugefügt oder festgestellt, dass er die ganze Zeit vorhanden war, was in Ordnung ist (oder Sie haben eine Fehlermeldung erhalten, weil Sie stattdessen den neuen GPG-Schlüssel ausgewählt habenNeuer SSH-Schlüssel : D).
3. SSH-Schlüssel mit gitHub-Konto verknüpfen : Wiederholen Sie den obigen Schritt für Ihr zweites Konto.

4. Bearbeiten der globalen Git-Konfiguration: Der letzte Schritt besteht darin, sicherzustellen, dass die globale Konfigurationsdatei alle Github-Konten kennt (sozusagen).
   Führen Sie git config --global --editdiese Option aus , um diese globale Datei zu bearbeiten. Wenn sich vim öffnet und Sie nicht wissen, wie Sie sie verwenden sollen, drücken Sie, ium in den Einfügemodus zu wechseln, bearbeiten Sie die Datei wie folgt und drücken Sie die Esc-Taste, um :wqden 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 jetzt versuchen, ein Repo zu pushen oder zu ziehen, werden Sie gefragt, welches GitHub-Konto mit diesem Repo verknüpft werden soll, und es wird nur einmal gefragt. Die lokale Konfiguration merkt sich 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 einfachere Lösung, um Verwirrungen zu vermeiden.

Für Windows-Benutzer, mehrere oder unterschiedliche Git-Konten für verschiedene Projekte zu verwenden.

Folgende Schritte: 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 der Überschrift "Allgemeine Anmeldeinformationen"

Dadurch werden die aktuellen Anmeldeinformationen entfernt. Jetzt können Sie jedes Projekt über Git Pull hinzufügen. Es wird nach Benutzername und Passwort gefragt.

Wenn Sie Probleme mit einem anderen Konto haben, gehen Sie genauso vor.

Vielen Dank

siehe Bild

Ich habe dies gerade für Windows herausgefunden und Anmeldeinformationen 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
git remote set-url origin https://USERNAME@github.com/USERNAME/PROJECTNAME.git

Das Format des Berechtigungsnachweises. https://github.com . teilt dem Helfer für Anmeldeinformationen die URL für die Anmeldeinformationen mit. Der 'useHttpPath' weist den Berechtigungsnachweismanager an, 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.

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 Commits die richtige E-Mail-Adresse zugeordnet sind, habe ich sichergestellt, dass die Datei ~ / .gitconfig die richtige E-Mail-Adresse hat.

Neben dem Erstellen mehrerer SSH-Schlüssel für mehrere Konten können Sie auch Mitarbeiter für jedes Projekt hinzufügen , die dieselben Konto-E-Mails verwenden, und das Kennwort dauerhaft speichern.

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

Ich habe mehrere Konten mit unterschiedlichen E-Mails eingerichtet und dann jedem Benutzer denselben Benutzer und dieselbe E-Mail-Adresse als einer der Mitarbeiter zugewiesen. Auf diese Weise kann ich auf alle Konten zugreifen, ohne einen SSH-Schlüssel hinzuzufügen oder zu einem anderen Benutzernamen und einer E-Mail für die Authentifizierung zu wechseln.

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

Erstellen Sie einfach einen weiteren SSH-Schlüssel.

Angenommen, Sie haben ein neues GitHub-Arbeitskonto. Erstellen Sie einfach einen neuen Schlüssel dafür:

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

Jetzt sollten Sie den alten und den neuen laufen lassen, um sie zu sehen:

ls -al ~/.ssh

Sie müssen die oben genannten Schritte nur einmal ausführen.

Von nun an führen Sie jedes Mal, wenn Sie zwischen den beiden wechseln möchten, einfach Folgendes aus:

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

Führen Sie den Vorgang erneut aus, um zum alten zu wechseln:

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

Eine andere einfachere Möglichkeit besteht darin, mehrere Desktop-Apps zu verwenden, z. B. das Konto A auf dem Github-Desktop und das Konto B auf dem Github Kraken

IntelliJ Idea verfügt über eine integrierte Unterstützung für https://www.jetbrains.com/help/idea/github.html#da8d32ae

Falls Sie sich nicht mit der ~/.ssh/confighier genannten Datei git config core.sshCommand "ssh -i ~/.ssh/custom_id_rsa"anlegen möchten , können Sie stattdessen das Repo ausführen, in dem Sie ein Commit von einem anderen Konto durchführen möchten.

Der Rest des Setups ist der gleiche:

1. Erstellen Sie einen neuen SSH-Schlüssel für das zweite Konto mit ssh-keygen -t rsa -f ~/.ssh -f ~/.ssh/custom_id_rsa

2. Melden Sie sich mit Ihrem anderen Konto bei github an, gehen Sie zu https://github.com/settings/keys und fügen Sie den Inhalt von ein~/.ssh/custom_id_rsa.pub

3. Stellen Sie sicher, dass Sie SSH anstelle von HTTPS als Remote-URL verwenden: git remote set-url origin git@github.com:upstream_project_teamname/upstream_project.git

Sie müssen nicht zwei verschiedene Konten für Personal und Arbeit führen. Tatsächlich empfiehlt Github, ein einziges Konto zu führen und beide zusammenzuführen.

Folgen Sie dem unten stehenden Link, um zusammenzuführen, wenn Sie entscheiden, dass nicht mehrere Konten verwaltet werden müssen.

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

Im Gegensatz zu anderen Antworten, wo Sie folgen müssen einige Schritte verwenden zwei verschiedene Github - Konto von derselben Maschine, für mich funktionierte es in zwei Schritten .

Sie müssen nur:

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

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

Verwenden Sie den folgenden Befehl, um die öffentlichen und privaten SSH-Schlüsselpaare zu generieren :

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"

Als Ergebnis der oben genannter Befehle, id_rsa_WORKund id_rsa_WORK.pubDateien werden für Ihr erstellt wird Arbeitskonto (ex - git.work.com) und id_rsa_PERSONALund id_rsa_PERSONAL.pubwird für Ihr erstellte persönliches Konto (ex - github.com).

Kopieren Sie nach der Erstellung den Inhalt aus jeder public ( *.pub) - Datei und führen Sie Schritt 2 für jedes Konto aus.

PS : Es ist nicht erforderlich, einen Hosteintrag für jedes Git-Konto in der ~/.ssh/configDatei vorzunehmen, wie in anderen Antworten erwähnt, wenn der Hostname Ihrer beiden Konten unterschiedlich ist.

Wenn Sie WSL installiert haben, können Sie zwei separate Git-Konten haben - eines unter WSL und eines unter Windows.

Sie sollten und dürfen nicht mit einigen allgemeinen Anmeldeinformationen zum Projekt pushen. Führen Sie nach dem Start auf einem neuen Computer die folgenden Schritte aus, um Ihre Gitlab-Anmeldeinformationen einzurichten und korrekt zu verwenden:

• Erstellen Sie die öffentlichen / privaten SSH-Schlüssel auf dem Computer
• Kopieren Einfügen des öffentlichen Schlüssels in die Benutzeroberfläche von gitlab / github ui (jeder, der über die cmd-Zeile angibt, wie es geht, bekommt ein kostenloses Bier ...)
• Stellen Sie sicher, dass Sie das Repo über den Git und nicht über die http-URL klonen
• Legen Sie den Git-Alias ​​fest, um zu vermeiden, dass das gleiche Präfix für den Befehl git ständig eingegeben wird
• Verwenden Sie während des Git-Commits IMMER die Autoren- und E-Mail-Flags
• Verwenden Sie Git wie gewohnt

All dies wie folgt:

 # 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. Navigieren Sie zu dem Verzeichnis, in dem Sie Ihre Änderungen auf ein anderes GitHub-Konto übertragen möchten.

2. Erstellen Sie einen neuen SSH-Schlüssel in Ihrem Terminal / Ihrer Befehlszeile.

   ssh-keygen -t rsa -C "Ihre-E-Mail-Adresse"

3. Folgendes wird dann angezeigt:

   Generieren eines öffentlichen / privaten RSA-Schlüsselpaars. Geben Sie die Datei ein, in der der Schlüssel gespeichert werden soll (/home/Ihr_Benutzername/.ssh/id_rsa):

Kopieren Sie den Pfad und fügen Sie ihn ein, gefolgt von einem identifizierbaren Namen für die Datei:

/home/your_username/.ssh/id_rsa_personal

4) Sie werden dann um Folgendes gebeten:

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

5) Sie können jetzt den folgenden Befehl eingeben, um alle SSH-Schlüssel anzuzeigen, die Sie auf Ihrem lokalen Computer haben:

ls -al ~/.ssh

Sie sollten Ihre neue SSH-Schlüsseldatei sehen können. Wie Sie in meinem sehen können, habe ich sowohl id_rsa_test als auch 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) Als nächstes müssen Sie den SSH-Schlüssel kopieren, der in der Datei id_rsa_personal.pub gespeichert ist. Sie können dies in einem Texteditor Ihrer Wahl öffnen. Ich verwende derzeit Atom und habe die Datei mit dem folgenden Befehl geöffnet:

atom ~/.ssh/id_rsa_personal.pub

Sie erhalten dann etwas Ähnliches:

ssh-rsa

7) Kopieren Sie diese und navigieren Sie zu Ihrem GitHub-Konto → Einstellungen → SSH- und GPG-Schlüssel. 8) Klicken Sie auf Neuer SSH-Schlüssel. Kopieren Sie den Schlüssel, geben Sie ihm einen Titel und fügen Sie ihn hinzu. 9) Schlüssel vom Terminal hinzufügen

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

10) Konfigurieren Sie Benutzer und Passwort.

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

11) Wir sind bereit, uns jetzt zu verpflichten und zu pushen.

git init
git add .
git commit 
git push