Mehrere github-accounts auf dem gleichen computer?

Versucht, auf mein beiden meiner eigentlichen "Arbeit" repos, und meine persönliche repo auf git-hub, von meinem computer.

Die work-Konto eingerichtet wurde, die erste, und alles funktioniert einwandfrei.

Meinem persönlichen Konto, kann aber nicht scheinen, zu schieben, zu meinem persönlichen repo, die sich unter einem anderen account/E-Mail.

Ich habe versucht, das kopieren meiner Arbeit-Schlüssel bis zu meinem persönlichen Konto, aber das wirft einen Fehler, denn natürlich kann ein Schlüssel werden nur an einem Konto.

Wie kann ich push/pull und von beiden Konten, von Ihrer jeweiligen github-Zugangsdaten?

Die Schritte in dem link http://net.tutsplus.com/tutorials/tools-and-tips/how-to-work-with-github-and-multiple-accounts gut für mich gearbeitet und ujust auf eine Sache hinzufügen, müssen Sie fügen Sie persönliche repo-Taste wird auch die Verwendung von<br>   ssh-add ~/.ssh/id_rsa_COMPANY <br/> sagen Sie den ssh-Agenten zu gehören, die Sie zur Nutzung.<hr/> Rest funktioniert gut für mich mit dem oben genannten tutorial.
"denn ein Schlüssel kann nur angebracht werden auf ein Konto" natürlich? warum?
Git 2.13 weiter unterstützt bedingten umfasst .gitconfig, die sind eine nützliche Methode, um Identitäten zu verwalten pro Ordner-Hierarchie. stackoverflow.com/a/36296990/901597
Mögliche Duplikate von Mehrere GitHub-Accounts & SSH-Config

InformationsquelleAutor Kevin Whitaker | 2010-10-05

215

Alles, was Sie tun müssen ist, konfigurieren Sie Ihren SSH-setup mit mehreren SSH-Schlüsselpaare.
- 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-keys (Win/msysgit)
  https://help.github.com/articles/generating-an-ssh-key/
Auch, wenn Sie die Arbeit mit mehreren repositories mit verschiedenen personas, die Sie benötigen, um sicherzustellen, dass Ihre einzelnen repositories haben, die Benutzer-Einstellungen überschrieben, entsprechend:

Einstellung Benutzername, E-Mail und GitHub token – Überschreiben die Einstellungen für die einzelnen repos
https://help.github.com/articles/setting-your-commit-email-address-in-git/

Hoffe, das hilft.

Hinweis:
Einige von Ihnen erfordern unterschiedliche E-Mails verwendet werden für unterschiedliche repositories von git 2.13 können Sie die E-Mail in einem Verzeichnis Bearbeiten die Globale config-Datei gefunden, unter: ~/.gitconfig mit Bedingungen etwa so:
```
[user]
    name = Pavan Kataria
    email = [email protected]

[includeIf "gitdir:~/work/"]
    path = ~/work/.gitconfig
```
Und dann Ihre Arbeit spezifische config ~/work/.gitconfig würde wie folgt Aussehen:
```
[user]
    email = [email protected]
```
Danke @alexg für die Unterrichtung mir dies in die Kommentare.

Der 3. link ist jetzt gebrochen (Mehrere SSH-Keys)
das erste Glied nun wieder leitet zu einer Seite, auf Nutzer vs. organisationskonten (nicht sicher, ob das, was ursprünglich beabsichtigt war). dieses tutorial war einfach zu Folgen und meine Probleme gelöst.
Weil ich nicht weiß, was das neue, aktualisierte link ist, so dass, wenn er Kenntnis von den aktualisierten link, dann wäre es irgendwie für ihn, um es hook up 🙂
Es ist schon fast 3 Jahre jetzt, links gebunden sind, zu brechen, und weiterhin zu brechen. Pflege zu finden, eine alternative Artikel oder Sie suchen nach der ursprünglichen Quelle wieder, so dass Sie dann freundlicherweise den link aktualisieren für mich, Kumpel? Ich kann nicht ewig halten, fixieren Gebrochener links.
Dies ist nicht eine Antwort, ohne die eine Zusammenfassung der kritischen Schritte im eigentlichen post. Diese Antwort hat bereits gelitten von link rot einmal, aber noch nicht die erforderlichen update-tob einer tatsächlichen Antwort auf die Frage.

InformationsquelleAutor Pavan
112

HTTPS:

ändern remote-url auf https:
```
git remote set-url origin https://[email protected]/USERNAME/PROJECTNAME.git
```
und Sie sind gut zu gehen:
```
git push
```
Um sicherzustellen, dass die commits angezeigt, wie ausgeführt, mit einem BENUTZERNAMEN, einer Einrichtung des Benutzer.name und Benutzer.E-Mail für dieses Projekt zu:
```
git config user.name USERNAME
git config user.email [email protected]
```
Die einfachste Lösung für den schnellen download von einem anderen private-repository.

InformationsquelleAutor Greg Leszek
48

Etwas in Form

Verwalten eines git-repo unter einem separaten github/bitbucket/whatever-Konto, müssen Sie zum generieren eines neuen SSH-Schlüssels.

Aber bevor wir starten können, drücken/ziehen repos mit Ihrer zweiten Identität, wir gotta get Sie in Form – nehmen wir an, Ihr system-setup mit einem typischen id_rsa und id_rsa.pub Schlüsselpaar. Jetzt Ihre tree ~/.ssh sieht wie folgt aus
```
$ tree ~/.ssh
/Users/you/.ssh
├── known_hosts
├── id_rsa
└── id_rsa.pub
```
Erste, name, key-pair – hinzufügen eines beschreibenden Namen wird Ihnen helfen, denken Sie daran, welche Taste verwendet wird, für welche Benutzer/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
```
Als Nächstes wollen wir generieren eines neuen Schlüsselpaares – ich werde hier den Namen des neuen Schlüssels github-otheruser
```
$ ssh-keygen -t rsa -b 4096 -f ~/.ssh/github-otheruser
```
Nun, wenn wir uns tree ~/.ssh sehen wir
```
$ tree ~/.ssh
/Users/you/.ssh
├── known_hosts
├── github-mainuser
├── github-mainuser.pub
├── github-otheruser
└── github-otheruser.pub
```
Nächsten, die wir brauchen, um das setup eine ~/.ssh/config - Datei, definieren die wichtigsten Konfigurationen. Wir werden es schaffen, mit der richtige owner-read/write-Berechtigung nur
```
$ (umask 077; touch ~/.ssh/config)
```
Öffnen, die Sie mit Ihrem bevorzugten editor und fügen Sie folgenden Inhalt
```
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 einigen vorhandenen repos Zusammenhang mit Ihrem primären github Identität. Aus diesem Grund werden die "Standard" github.com Host setup verwenden Sie Ihre mainuser - Taste. Wenn Sie nicht wollen, zu Gunsten eines Kontos, über andere, ich werde Ihnen zeigen, wie zu aktualisieren bestehenden repos auf Ihrem system zu verwenden, eine aktualisierte ssh-Konfiguration.

Fügen Sie Ihre neue SSH-Schlüssel auf github

Kopf über github.com/settings/keys, um Ihre neue öffentlichen Schlüssel

Können Sie die public-key-Inhalt mit kopieren/einfügen auf github
```
$ cat ~/.ssh/github-otheruser.pub
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDBVvWNQ2nO5...
```
Nun Ihre neue Benutzerkennung ist alle setup – unten zeigen wir Ihnen, wie es zu benutzen.

Immer Sachen gemacht: Klonen eines repo -

So, wie kommt das zusammen arbeiten mit git und github? Gut, weil Sie nicht haben, können Sie ein Huhn ohne ei, die wir betrachten das Klonen eines bestehenden repo. Diese situation könnte auf Sie zutreffen, wenn Sie haben ein neues github-Konto für Ihren Arbeitsplatz, und Sie wurden Hinzugefügt, um ein betriebliches Projekt.

Sagen wir mal github.com/someorg/somerepo bereits vorhanden ist, und Sie wurden Hinzugefügt, um es – Klonen ist so einfach wie
```
$ git clone github.com-otheruser:someorg/somerepo.git
```
Dass Fett Teil muss match der Host Namen, die wir eingerichtet in Ihrem ~/.ssh/config - Datei. Richtig verbindet, git, um die entsprechenden IdentityFile und ordnungsgemäß authentifiziert Sie mit github

Immer Sachen gemacht: erstellen einer neuen repo -

Gut, weil Sie nicht haben, können Sie ein Huhn ohne ei, schauen wir uns die Veröffentlichung einer neuen repo auf dem sekundären Konto. Diese situation gilt für die Benutzer erstellen neue Inhalte mit sekundären github-account.

Nehmen wir an, Sie haben bereits getan, ein wenig Arbeit vor Ort und Sie sind nun bereit, um push zu github. Sie können Folgen Sie zusammen mit mir, wenn Sie möchten,
```
$ cd ~
$ mkdir somerepo
$ cd somerepo
$ git init
```
Konfigurieren Sie nun dieses repo zu nutzen, Ihre Identität
```
$ git config user.name "Mister Manager"
$ git config user.email "[email protected]"
```
Nun machen Sie Ihre ersten commit
```
$ echo "hello world" > readme
$ git add .
$ git commit -m "first commit"
```
Überprüfen Begehen, um zu sehen, eine neue Identität verwendet wurde, mit git log
```
$ git log --pretty="%H %an <%ae>"
f397a7cfbf55d44ffdf87aa24974f0a5001e1921 Mister Manager <someuser@some.org>
```
Okay, Zeit, um push zu github! Da github nicht kennt, über unsere neue repo noch, zuerst zu gehen github.com/new und erstellen Sie Ihre neue repo – name es somerepo

Nun, konfigurieren Sie Ihr repo "reden" github mit der korrekten Identität/Zeugnisse, die wir haben, fügen Sie eine remote. Vorausgesetzt, Ihr github-Benutzernamen für Ihr neues Konto ist someuser ...
```
$ git remote add origin github.com-otheruser:someuser/somerepo.git
```
Dass Fett Teil ist absolut entscheidend und es muss match der Host definiert, dass wir in Ihrem ~/.ssh/config Datei

Schließlich, drücken Sie die repo -
```
$ git push origin master
```
Update eines bestehenden repo zu verwenden, eine neue SSH-Konfiguration

Sagen, Sie haben bereits eine repo geklont, aber jetzt wollen Sie eine neue SSH-Konfiguration. In dem obigen Beispiel haben wir gehalten, Ihre bestehenden repos im Takt durch die Zuordnung Ihrer bisherigen id_rsa/id_rsa.pub Schlüsselpaar zu Host github.com in deiner SSH-config-Datei. Es ist nichts falsch mit diesem, aber ich habe mindestens 5 github-Konfigurationen jetzt, und ich weiß nicht wie das denken von Ihnen als "Standard" Konfiguration – ich würde eher explizit über jeden.

Vorher hatten wir diese
```
Host github.com
  User git
  IdentityFile ~/.ssh/github-mainuser

Host github.com-otheruser
  HostName github.com
  User git
  IdentityFile ~/.ssh/github-otheruser
```
Also wir werden jetzt aktualisiert, um diese (Veränderungen in Fett)
```
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
```
Aber das bedeutet, dass nun alle bestehenden repo mit einem github.com remote funktioniert nicht mehr mit dieser Identität-Datei. Aber keine Sorge, es ist eine einfache Lösung.

Ist die Aktualisierung der bestehenden repo zu verwenden Ihre neue SSH-Konfiguration, öffnen Sie einfach die repo git config-Datei und aktualisieren Sie die url!
```
$ cd existingrepo
$ nano .git/config
```
Update der remote-origin-Feld (änderungen im Fett)
```
[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-key-Datei Berechtigungen

Wenn Sie laufen in Probleme mit Ihrem öffentlichen Schlüssel nicht korrekt funktioniert, SSH ist ziemlich streng auf die Datei-Berechtigungen erlaubt, auf Ihrem ~/.ssh Verzeichnis und die entsprechenden key-Dateien

Als Faustregel gilt, alle Verzeichnisse werden sollte 700 und alle Dateien werden sollte 600 - das bedeutet, Sie sind Eigentümer-Lesen/schreiben-nur – keine andere Gruppe/Benutzer können 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 ich es Schaffe, meine SSH-keys

Ich verwalten separater SSH-Schlüssel für jeden Rechner ich mich verbinden, so dass wenn überhaupt ein Schlüssel ist kompromittiert, habe ich nicht die update-Tasten auf jedem anderen Ort, den ich verwendet habe, ist der key. Das ist so, als bekommen Sie eine Benachrichtigung von Adobe, dass 150 Millionen Nutzerdaten gestohlen wurde – jetzt müssen Sie stornieren, die Kreditkarte und jedem update-service-das hängt davon ab – was für ein ärgernis.

Hier ist, was mein ~/.ssh Verzeichnis sieht so aus: ich habe eine .pem Schlüssel für jeden Benutzer, in einem Ordner für jede domain die ich verbinden. Ich benutze .pem Tasten, also Brauch ich nur eine Datei pro Schlüssel.
```
$ 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 entsprechenden /.ssh/config Datei – offensichtlich ist die github Kram ist relevant für die Beantwortung dieser Frage über github, aber diese Antwort will statten Sie mit das wissen um die Verwaltung Ihrer ssh-Identitäten auf eine beliebige Anzahl von Diensten/Rechnern.
```
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
```
Immer Ihre SSH-public-key aus einer PEM-Schlüssel

Oben Sie bemerkt, dass ich nur noch eine - Datei für jede Taste. Wenn ich einen öffentlichen Schlüssel, die ich einfach generieren, wie gebraucht.

So, wenn github fragt nach Ihren öffentlichen ssh-Schlüssel, führen Sie diesen Befehl, um die Ausgabe der öffentliche Schlüssel auf stdout aus – kopieren/einfügen, wo Sie benötigt
```
$ ssh-keygen -y -f someuser.pem
ssh-rsa AAAAB3NzaC1yc2EAAAA...
```
Beachten Sie, dies ist auch der gleiche Prozess, den ich verwenden für das hinzufügen von meinen key zu einem beliebigen remote-Maschine. Die ssh-rsa AAAA... Wert wird kopiert, um Sie auf der Fernbedienung die ~/.ssh/authorized_keys Datei

Konvertieren Sie Ihre id_rsa/id_rsa.pub Schlüsselpaare zu PEM-format

Also wollen Sie zähmen Sie wichtige Dateien und reduzieren auf einige Datei-system cruft? Konvertieren Sie Ihre Schlüssel-paar zu einem single PEM ist einfach
```
$ cd ~/.ssh
$ openssl rsa -in id_rsa -outform pem > id_rsa.pem
```
Oder, zusammen mit unseren obigen Beispielen, die wir umbenannt id_rsa -> github-mainuser und id_rsa.pub -> github-mainuser.pub – so
```
$ cd ~/.ssh
$ openssl rsa -in github-mainuser -outform pem > github-mainuser.pem
```
Nun nur um sicherzugehen, dass wir konvertiert haben, dies zu korrigieren, werden Sie wollen, stellen Sie sicher, dass die generiert öffentlichen Schlüssel passt zu Ihrem alten öffentlichen Schlüssel
```
# 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==
```
Nun, dass Sie Ihre github-mainuser.pem - Datei, können Sie sicher löschen Sie Ihre alten github-mainuser und github-mainuser.pub Dateien – nur die PEM-Datei ist notwendig; nur generieren, den öffentlichen Schlüssel, Wann immer Sie es brauchen ^_^

Erstellen PEM-Schlüssel von Grund auf neu

Brauchen Sie nicht zu erstellen, die private - /public-key pair und dann konvertieren einer einzelnen PEM-Schlüssel. Sie können die PEM-Schlüssel direkt.

Erstellen wir ein newuser.pem
```
$ openssl genrsa -out ~/.ssh/newuser.pem 4096
```
Immer die öffentlichen SSH-Schlüssel der gleiche
```
$ ssh-keygen -y -f ~/.ssh/newuser.pem
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACA ... FUNZvoKPRQ==
```
Ich verstehe, das ist eine alte Frage, aber dass doesn ' T entschuldigen Sie die Tatsache, dass fast jede Antwort hier ist ein link zu einigen Tutorials und unterliegt daher der link rot. Es ist gut, link-Quellen/Zitate, aber Sie nicht stützen kann auf ein link, wenn Sie nicht fassen die kritischen bits in deine Antwort hier gepostet.
Ich von Ihnen positiv bewertet werden die gute und ausführliche Antwort, wie klar der richtige Weg, es zu tun. Mein Problem mit ihm ist, dass seine komplexen, und nach ein paar Jahren mit einige Konten, habe ich einen neuen bekommen, dann kann sich daran erinnern, wie es zu tun, "den richtigen Weg". Mein Weg unten ist sehr einfach - ich nehme einfach 3 neue Dateien und ein neues Skript, und ich bin gut zu gehen. Seine funktionierte einwandfrei für mich seit vielen Jahren. Der Leser kann entscheiden, was am besten für Sie funktioniert.
DavidH bin ich dankbar für die Bemerkung. Die Antwort fühlt sich Komplex, wenn man es als ganzes, sondern der Leser muß wirklich nur die Sorge sein/sich selbst mit einem kleinen Teil der Antwort, wenn Ihr einziges Ziel ist das hinzufügen einer anderen github-Identität – alle übrigen Teile der Antwort, die darauf gerichtet sind, die Einstellung, die Sie mit einer robusten Lösung für die Verwaltung von SSH-Schlüsseln im Allgemeinen, und sind vollständig optional.
Ich denke git clone github.com-otheruser:someorg/somerepo.git werden muss git clone [email protected]:someorg/somerepo.git (durch hinzufügen der git@). Leastways, das ist das, was ich brauchte.
alle Kommandozeilen-Optionen, wie die Angabe der user, kann man in der SSH-config als gut. Zum Beispiel: Host github.com (newline) User git (newline) IdentityFile ...

InformationsquelleAutor user633183
23

Durch die Schaffung von verschiedenen Hosts, Aliase github.com in deiner ~/.ssh/config,
und dass jeder host-alias seinen eigenen ssh-key, Sie können ganz einfach nutzen mehrere
github-accounts ohne Verwirrung.
Das ist, weil github.com unterscheidet, nicht durch die user, die immer nur git,
aber durch den ssh-Schlüssel, die Sie verwendet, um zu verbinden.
Geben Sie einfach Ihre remote-Ursprünge mit Ihrem eigenen host aliases."

Die obige Zusammenfassung ist mit freundlicher Genehmigung von Kommentare auf den blog-post unten.

Ich habe festgestellt, das die Erklärung der klarste. Und es funktioniert für mich, zumindest als der April 2012.

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

Sie werden wahrscheinlich auch brauchen, um ausführen $ ssh-add ~/.ssh/id_rsa_COMPANY - siehe Fehler: Permission denied (publickey) - Benutzer-Dokumentation

InformationsquelleAutor mishaba
21

Details auf http://net.tutsplus.com/tutorials/tools-and-tips/how-to-work-with-github-and-multiple-accounts/ in Verbindung mit mishaba arbeiten sehr gut für mich.

Dieser Seite:
```
$ touch ~/.ssh/config
```
Dann Bearbeiten Sie die Datei, um so etwas wie dieses (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 würde auch beachten, dass entweder "github.com" oder "github-UNTERNEHMEN" müssten genutzt werden, wenn dabei ein Klon (und wahrscheinlich auch andere Befehle) wie git clone git@github-COMPANY/repo/name.git um den korrekten ssh-Schlüssel.
Wie würde ich dies umsetzen, wenn ich hatte, zu Klonen, die über https? git clone https://github-COMPANY/GitUserName/projectname.git scheint nicht zu funktionieren. Die default-Schlüssel verwenden github.com funktioniert Prima.
tun Sie absolut müssen gehen über https? Jedes mal, wenn Sie wollen, ziehen/schieben Sie Sie zur Eingabe Ihrer Benutzeranmeldeinformationen. am besten wäre es, wenn Sie das tun könnten git://github-UNTERNEHMEN...projectname.git. gibt es irgendwelche Fehler messaging für die https-Aufruf?
Ich hatte einige Probleme mit port 22 trotz scheinbar wurde geöffnet für mich. ssh: connect to host github.com port 22: Bad file number fatal: The remote end hung up unexpectedly. https war der einzige Weg, so weit. $ git clone https://github-USER/UserName/test_project_user.git Cloning into test_project_user... error: Couldn't resolve host 'github-USER' while accessing https://github-USER/N UserName/test_project_user.git/info/refs fatal: HTTP request failed Ich bin mir nicht sicher, ob es im Zusammenhang mit der config-Datei oder die Art und Weise, die ich bin versucht zu emulieren git-Aufruf mit https.
Letztlich, ich werde eine eingehende Analyse versucht alles und poste es entsprechend als eine Frage.

InformationsquelleAutor Matthew Skelton
11

Ich verwende shell-Skripte zu wechseln, mich zu was auch immer-account möchte ich "aktiv" sein. Im wesentlichen beginnen Sie mit einer frischen start, erhalten Sie ein Konto richtig konfiguriert und arbeiten, dann verschieben Sie diese Dateien an einen Namen mit dem korrekten Präfix. Von da an kann man mit dem Befehl "github", oder "gitxyz" 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 "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 mit diesem. Ich habe auch ein Skript ausführen, in Xcode (für Mac-Benutzer), so würde es nicht bauen, mein Projekt, es sei denn, ich hatte die richtige Einstellung (seit der Verwendung von git):

Skript ausführen, platziert nach Abhängigkeiten (mit /bin/ksh als shell):
```
if [ "$(git config --global --get user.email)" != "dhoerl@<company>.com" ]
then
    exit 1
fi
```
EDIT: neue tests für neue Dateien, die Existenz und das kopieren von alten Dateien in /tmp zu Adresse Kommentar von @naomik unten.

Seien Sie vorsichtig beim buchen von kopieren und einfügen von Textbausteinen/verbatim Antworten auf mehrere Fragen, diese sind in der Regel gekennzeichnet als "Spam" durch die Gemeinde. Wenn Sie dies tun, dann bedeutet es meist die Fragen sind Duplikate, so dass diese Flagge als solche, statt: stackoverflow.com/questions/7548158, stackoverflow.com/questions/3225862, stackoverflow.com/questions/7924937
Dies ist ein Alptraum. Wenn jemand waren, um dieses Skript auszuführen, bevor Sie verstehen, dass Ihre id_rsa und id_rsa.pub Schlüssel gelöscht würden, werden, könnten Sie gesperrt werden aus der Fernbedienung.
das Skript aktualisiert, um sowohl zu prüfen, ob neue Dateien zuerst, und speichern Sie alte Dateien in /tmp
vielen Dank für die Zeit nehmen, zu aktualisieren

InformationsquelleAutor David H

Gehen Sie zu ~/.ssh
Erstellen Sie eine Datei namens config(keine Erweiterung )

Open config file & fügen Sie unter codes. (nach deinem-Konto)

Konto 1

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

Konto 2

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

Konto 3

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

Fügen Sie remote-url wie folgt

Konto 1

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

Konto 2

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

Konto 3

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

Stellen Sie sicher, dass IdentityFile Namen sind die gleichen, wie Sie bei der ssh-Schlüsselgenerierung.

InformationsquelleAutor Pranav V R

8

Diese Antwort ist für Anfänger (keine-git-gurus). Ich hatte vor kurzem dieses problem und vielleicht seine nur mich, aber die meisten Antworten Schienen erfordern vielmehr Voraus, das Verständnis von git. Nach der Lektüre mehrere stack overflow Antworten, inklusive diesem thread, hier sind die Schritte, die ich brauchte, um zu ergreifen, um das einfache wechseln zwischen den GitHub-accounts (z.B. übernehmen zwei GitHub-Konten github.com/personal und gitHub.com/work):
1. Überprüfung der vorhandenen ssh-keys: Terminal Öffnen und diesen Befehl ausführen, um zu sehen/Liste vorhandenen ssh-keys ls -al ~/.ssh
  Dateien mit der Erweiterung .pub sind Ihre ssh-Schlüssel verwenden, so sollten Sie haben zwei für die personal und work Konten. Wenn es nur eine oder keine, seine Zeit zu erzeugen andere Weise überspringen.
  - Generieren ssh-Schlüssel: login auf github (entweder die Arbeit oder persönliche acc.), navigieren Sie zu Einstellungen und kopieren Sie die entsprechende E-Mail.
  nun zurück zum Terminal und führen Sie ssh-keygen -t rsa -C "the copied email" Sie werden sehen:
  
  Generating public/private rsa key pair.
  
  Geben Sie den Dateinamen ein unter dem der Schlüssel gespeichert wird (/.../.ssh/id_rsa):
  
  id_rsa ist die Standard-Namen für die bald zu generierten ssh-Schlüssel, so kopieren Sie den Pfad und benennen Sie die Standardeinstellung, z.B. /.../.ssh/id_rsa_work wenn die Erzeugung für Arbeit-account. geben Sie ein Kennwort oder geben Sie einfach zu ignorieren und zu, wirst du etwas ähnliches Lesen, wie Die Taste randomart Bild: und das Bild. getan.
  Wiederholen Sie diesen Schritt, wenn Sie mehr für Ihre zweite github-account. Stellen Sie sicher, dass Sie die richtige E-Mail-Adresse und einen anderen ssh-key name (z.B. id_rsa_personal) zu vermeiden überschreiben.
  In dieser Phase, Sie sollten sehen, zwei ssh-Schlüssel beim laufen ls -al ~/.ssh wieder.
2. Associate ssh-Schlüssel (mit dem gitHub-account: Nächste Schritt ist, kopieren Sie die ssh-Schlüssel, führen Sie diesen aber den Ersatz Ihrer eigenen ssh-Schlüssel name: pbcopy < ~/.ssh/id_rsa_work.pub ersetzen id_rsa_work.pub mit dem, was du genannt dein.
  Nun, unsere ssh-Schlüssel wird in die Zwischenablage kopiert haben, gehen Sie zurück zu github-account [Stellen Sie sicher, dass Sie eingeloggt sind, um zu arbeiten-Konto, wenn Sie die ssh-Schlüssel, den Sie kopiert haben, wird id_rsa_work] und navigieren Sie zu
  Einstellungen - SSH-und GPG-Schlüssel und klicken Sie auf Neue SSH-Schlüssel - Taste (nicht Neuen GPG-Schlüssel btw :D)
  geben Sie einige Titel für diesen Schlüssel, fügen Sie den Schlüssel und klicken Sie auf ' Hinzufügen SSH key. Sie haben nun entweder erfolgreich Hinzugefügt, den ssh-Schlüssel oder es bemerkt hat es die ganze Zeit, die ist in Ordnung (oder Sie haben einen Fehler, da Sie ausgewählt Neuen GPG-Schlüssel statt Neue SSH-Schlüssel :D).
3. Associate ssh-Schlüssel (mit dem gitHub-account: Wiederholen Sie die genannten Schritte für das zweite Konto.
4. Bearbeiten Sie die Globale git Konfiguration: Letzte Schritt ist, um sicherzustellen, dass die Globale Konfigurationsdatei ist sich bewusst, alle github-accounts (so zu sagen).
  Führen Sie git config --global --edit Bearbeiten diese Globale Datei, wenn dies öffnet vim und Sie nicht wissen, wie es zu benutzen, drücken Sie i um in den Einfügemodus zu wechseln, Bearbeiten Sie die Datei wie unten, und drücken Sie esc, gefolgt von :wq um den Einfügemodus zu verlassen:
  
  [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
Vollbracht! nun, wenn Sie versuchen, zu schieben oder ziehen aus einem repo, werden Sie aufgefordert, die GitHub-account verknüpft werden soll mit diesem repo und seinen gebeten nur einmal die lokale Konfiguration werden sich erinnern, dieser link und nicht die Globale Konfiguration, so können Sie arbeiten auf verschiedenen repos, die verknüpft sind mit verschiedenen Konten ohne Bearbeiten der globalen Konfiguration jedes mal.

Ich glaube, ich Liebe dich.
Sie sollte tags für die Antworten, diese ist für mac OS.

InformationsquelleAutor Lukas
3

Einfacher und Leicht zu beheben, zu vermeiden, Verwirrungen..

Für Windows-Benutzer, um mehrere oder verschiedene git-Konten für verschiedene Projekte.

Folgenden Schritte aus:
Gehen Sie die Systemsteuerung und Suchen Sie den Anmeldeinformations-Manager.
Dann Gehen Sie zum Anmeldeinformations-Manager -> Windows-Anmeldeinformationen

Entfernen Sie nun die git:https//github.com Knoten unter Generische Anmeldeinformationen Überschrift

Damit entfernen Sie die aktuellen Anmeldeinformationen. Jetzt können Sie jedes Projekt mit git pull fragt er nach Benutzername und Passwort.

Wenn Sie irgendwelche Problem mit anderen tun das gleiche Verfahren.

Dank

siehe Bild

Dies war die einzige Sache, die für mich gearbeitet. Danke.

InformationsquelleAutor Raja Shakir
2

Fand ich dieses Schmuckstück sehr nützlich zu sein: sshwitch

https://github.com/agush22/sshwitch

http://rubygems.org/gems/sshwitch

Hilft es, zu wechseln, ssh-Schlüssel. Denken Sie an das sichern erstmal alles!

Auch, um sicherzustellen, dass verpflichtet haben, die richtige E-Mail-Adresse mit Ihnen verbunden sind, machte ich sicher, dass die ~/.gitconfig Datei hatte die richtige E-Mail-Adresse.

InformationsquelleAutor agsdot
2

Neben der Schaffung von mehrere SSH-Keys für mehrere Konten, können Sie auch prüfen, hinzufügen Mitarbeiter bei jedem Projekt mit dem gleichen Konto E-Mails und speichern Sie das Passwort fest.
```
#this store the password permanently
$ git config --global credential.helper wincred
```
Habe ich das setup mehrere Konten mit unterschiedlichen E-Mails, dann legen Sie die gleichen Benutzer-und E-Mail für jedes Konto als einer der Mitarbeiter. Auf diese Weise kann ich den Zugriff auf alle Konten, ohne das hinzufügen des SSH-Schlüssels, oder das Umschalten auf einen anderen Benutzernamen und E-Mail zur Authentifizierung.

InformationsquelleAutor Chetabahana
1

Die einfachste und einfache Ansatz (IMHO) - keine config-Dateien, die nicht zu viel Aufwand

Erstellen Sie einfach weitere ssh-Schlüssel.

Angenommen, Sie haben aa neue Arbeit GitHub-account, erstellen Sie einen neuen Schlüssel für Sie:
```
sh-keygen -t rsa -C "email@work_mail.com" -f "id_rsa_work_user1"`
```
Nun sollten Sie das alte und das neue, Sie zu sehen, laufen:
```
ls -al ~/.ssh
```
Müssen Sie zum ausführen der oben nur einmal.

Ab jetzt, jedes mal, wenn Sie wollen, um zwischen den beiden wechseln, führen Sie einfach:
```
ssh-add -D
ssh-add ~/.ssh/id_rsa_work_user1 #make to use this without the suffix .pub
```
Um den Schalter in die alte, wieder laufen:
```
 ssh-add -D
 ssh-add ~/.ssh/<previous id_rsa>
```
InformationsquelleAutor Kohn1001
0

Sie nicht zu pflegen haben zwei verschiedene Konten für personal und Arbeit. In der Tat, Github Empfiehlt Sie verwalten ein einziges Konto, und hilft Ihnen, verschmelzen beide.

Folgen Sie den unten stehenden link, um zu verschmelzen, wenn Sie sich entscheiden, es gibt kein müssen pflegen mehrere accounts.

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

InformationsquelleAutor Eric Blair
0

Im Gegensatz zu anderen Antworten, denen Sie Folgen müssen, paar Schritte zu verwenden zwei verschiedene github account vom gleichen Rechner, bei mir funktionierte es in zwei Schritte.

Brauchen Sie nur :

1) generieren SSH-public-key-Schlüsselpaar für jedes Konto unter ~/.ssh Lage, mit unterschiedlichen Namen und

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

Generieren, die SSH-public-und private-key-Paare verwenden Sie 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"
```
Als Ergebnis der oben genannten Befehle, id_rsa_WORK und id_rsa_WORK.pub - Dateien erstellt werden, die für Ihre Arbeit - Konto (ex - git.work.com) und id_rsa_PERSONAL und id_rsa_PERSONAL.pub erstellt für Ihre persönlichen - Konto (ex - github.com).

Einmal erstellt, kopieren Sie den Inhalt aus jeder öffentlichen (*.pub) Datei und führen Sie Schritt 2 für jedes Konto.

PS : es ist nicht erforderlich, um einen host-Eintrag für jeden git-Konto unter ~/.ssh/config - Datei wie bereits in anderen Antworten, wenn der hostname Ihrer zwei Konten unterschiedlich sind.

Wie schalten Sie zwischen den beiden Konten auf Ihrem lokalen PC?
Es gibt keine Notwendigkeit zu wechseln. Wenn du clone a Repository im lokalen die account Infos gespeichert werden, die durch die git in Ihrem lokalen repo. Also, wenn du git push-oder pull-innen, die lokale repo die obige Konfiguration erkennen, welches Konto zu berücksichtigen.

InformationsquelleAutor Sahil Chhabra
0

anderer einfacher Weg ist die Verwendung mehrerer desktop-apps, wie das, was ich Tue, mit Ein Konto auf Github desktop, während der Verwendung von Konto B auf Github Kraken

InformationsquelleAutor Jet Yu
0

Wenn Sie geschehen, haben WSL installiert, können Sie zwei separate git-Konten - one-auf WSL und einen in windows.

InformationsquelleAutor Almenon
0

dachte nur das für Windows, unter Verwendung von Anmeldeinformationen für jedes repo:
```
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://[email protected]/USERNAME/PROJECTNAME.git
```
Format des credential.https://github.com. sagt der credential helper die URL für die Anmeldeinformationen ein.
Die 'useHttpPath", erzählt der credential-manager verwenden, um den Pfad für die Anmeldeinformationen ein. Wenn useHttpPath weggelassen, dann ist die credential-manager speichern Sie eine Berechtigung für https://github.com. Wenn er enthalten ist, dann ist die credential-manager-speichern von mehreren Anmeldeinformationen, die ist, was ich wirklich wollte.

InformationsquelleAutor Craig - MSFT

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.