Wiele kont github na tym samym komputerze?

418

Próbuję pracować z moimi rzeczywistymi repozytoriami „roboczymi” i osobistymi repozytoriami w git hub z mojego komputera.

Konto robocze zostało utworzone jako pierwsze i wszystko działa bezbłędnie.

Moje konto osobiste nie może jednak przesyłać do mojego osobistego repozytorium, które jest skonfigurowane pod innym kontem / adresem e-mail.

Próbowałem skopiować mój klucz do pracy na konto osobiste, ale generuje to błąd, ponieważ klucz można oczywiście przypisać tylko do jednego konta.

Jak mogę wypychać / wyciągać dane z obu kont na podstawie odpowiednich poświadczeń github?

Kevin Whitaker
źródło
3
Kroki podane w linku http://net.tutsplus.com/tutorials/tools-and-tips/how-to-work-with-github-and-multiple-accounts działały dla mnie dobrze i słusznie dodając jedną rzecz muszę dodać ci osobisty klucz repo, również używając <br> & nbsp; ssh-add ~/.ssh/id_rsa_COMPANY <br/> aby poinformować ssh-agenta, aby podał go do użycia. <hr /> Rest działa dla mnie dobrze z wyżej wymienionym samouczkiem.
Brut3e
2
„ponieważ oczywiście klucz można przypisać tylko do jednego konta” oczywiście? dlaczego?
Sparr
Git 2.13 i nowsze obsługują warunki warunkowe w .gitconfig, które są użytecznym sposobem zarządzania tożsamościami w hierarchii folderów. stackoverflow.com/a/36296990/901597
Joe Bowbeer
Możliwy duplikat wielu kont GitHub i konfiguracji SSH
Code-Apprentice

Odpowiedzi:

275

Wszystko, co musisz zrobić, to skonfigurować konfigurację SSH z wieloma parami kluczy SSH.

Ponadto, jeśli pracujesz z wieloma repozytoriami przy użyciu różnych osób, musisz upewnić się, że w poszczególnych repozytoriach ustawienia użytkownika zostały odpowiednio zastąpione:

Ustawianie nazwy użytkownika, adresu e-mail i tokena GitHub - Przesłanianie ustawień dla poszczególnych repozytoriów https://help.github.com/articles/setting-your-commit-email-address-in-git/

Mam nadzieję że to pomoże.

Uwaga: niektórzy z was mogą wymagać użycia różnych e-maili dla różnych repozytoriów, od git 2.13 możesz ustawić e-maile na podstawie katalogu, edytując globalny plik konfiguracyjny znajdujący się pod adresem: ~/.gitconfigużywając warunkowych takich jak:

[user]
    name = Pavan Kataria
    email = [email protected]

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

A następnie konfiguracja specyficzna dla pracy ~ / work / .gitconfig wyglądałaby następująco:

[user]
    email = [email protected]

Dziękuję @alexg za poinformowanie mnie o tym w komentarzach.

Pavan
źródło
4
Trzeci link jest teraz zepsuty (wiele kluczy SSH)
RustyTheBoyRobot
12
ten pierwszy link przekierowuje teraz na stronę Konta użytkownika kontra konta organizacji (nie jestem pewien, czy to było pierwotnie zamierzone). ten samouczek był łatwy do naśladowania i rozwiązał moje problemy.
Eric H.
1
@Camilo Ponieważ nie wiem, co to jest nowy zaktualizowany link, więc jeśli wie o zaktualizowanym linku, byłoby miło, gdyby go podłączył :)
Pavan
4
@AlmasAdilbek Minęły już prawie 3 lata, linki zerwają i nadal się psują. Chcesz znaleźć alternatywny artykuł lub ponownie znaleźć oryginalne źródło, abyś mógł następnie zaktualizować link dla mnie, kolego? Nie mogę wiecznie naprawiać zepsutych linków.
Pavan
3
To nie jest odpowiedź bez podsumowania najważniejszych kroków w twoim aktualnym poście. Ta odpowiedź już raz cierpiała na zgniliznę linków, ale nie spowodowała, że ​​niezbędna aktualizacja zaktualizowała rzeczywistą odpowiedź na pytanie.
Dziękuję
139

Użyj HTTPS:

zmień zdalny adres URL na https:

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

i jesteś gotowy, aby przejść:

git push

Aby upewnić się, że wyglądają jak rewizje przeprowadzane przez nazwę użytkownika, jednej konfiguracji może user.name i user.email dla tego projektu, za:

git config user.name USERNAME
git config user.email [email protected]
Greg Leszek
źródło
8
Najprostsze rozwiązanie do szybkiego pobrania z innego prywatnego repozytorium.
Jaap Geurts
1
to najlepsze rozwiązanie, jakie znalazłem w stosach
Harvinder Singh
To rozwiązanie zapewnia najprostszą metodę, ponieważ nie chciałem dodawać więcej kluczy ssh. Tylko uwaga, jeśli już ustawić swoje user.namei user.emailz --globalflagą, tylko robić to, co mówi powyżej, aby ustawić go lokalnie tylko, że jednym repo. To rozwiązało wiele problemów. Teraz usuń stare repo ....
thatrobotguy
71

Nabierać formy

Aby zarządzać repozytorium git pod osobnym kontem github / bitbucket / cokolwiek, wystarczy wygenerować nowy klucz SSH.

Ale zanim zaczniemy pchanie / ciągnięcie repo z drugiej tożsamości, muszę się dostać się do kształtu - załóżmy, Twój system jest skonfigurowany z typowym id_rsai id_rsa.pubpary kluczy. W tej chwili twój tree ~/.sshwygląd wygląda tak

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

Najpierw nazwij tę parę kluczy - dodanie opisowej nazwy pomoże ci zapamiętać, który klucz jest używany dla danego użytkownika / pilota

# 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

Następnie wygenerujmy nową parę kluczy - tutaj nazwiemy nowy kluczgithub-otheruser

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

Teraz, kiedy patrzymy tree ~/.ssh, widzimy

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

Następnie musimy ustawić ~/.ssh/configplik, który zdefiniuje nasze kluczowe konfiguracje. Stworzymy go z odpowiednimi uprawnieniami tylko do odczytu / zapisu właściciela

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

Otwórz to za pomocą swojego ulubionego edytora i dodaj następującą zawartość

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

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

Przypuszczalnie będziesz mieć kilka istniejących repozytoriów powiązanych z twoją podstawową tożsamością github. Z tego powodu „domyślny” github.com Hostjest skonfigurowany do używania twojego mainuserklucza. Jeśli nie chcesz faworyzować jednego konta nad drugim, pokażę ci, jak zaktualizować istniejące repozytoria w systemie, aby użyć zaktualizowanej konfiguracji ssh.


Dodaj nowy klucz SSH do github

Wejdź na github.com/settings/keys, aby dodać nowy klucz publiczny

Możesz pobrać zawartość klucza publicznego za pomocą: skopiuj / wklej ją do github

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

Teraz twoja nowa tożsamość użytkownika jest skonfigurowana - poniżej pokażemy ci, jak z niej korzystać.


Wykonanie rzeczy: klonowanie repozytorium

Więc jak to działa w połączeniu z git i github? Ponieważ nie możesz mieć kurczaka i jajka, przyjrzymy się klonowaniu istniejącego repozytorium. Ta sytuacja może dotyczyć Ciebie, jeśli masz nowe konto github dla swojego miejsca pracy i zostałeś dodany do projektu firmowego.

Powiedzmy, że github.com/someorg/somerepojuż istnieje i zostałeś do tego dodany - klonowanie jest tak proste, jak

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

Ta pogrubiona część musi być zgodna z Hostnazwą, którą ustawiliśmy w twoim ~/.ssh/configpliku. To poprawnie łączy git z odpowiednim IdentityFilei poprawnie uwierzytelnia cię w github


Zadania: tworzenie nowego repozytorium

Ponieważ nie możesz mieć kurczaka i jajka, przyjrzymy się opublikowaniu nowego repozytorium na Twoim drugim koncie. Ta sytuacja dotyczy użytkowników, którzy tworzą nowe treści przy użyciu dodatkowego konta github.

Załóżmy, że wykonałeś już trochę pracy lokalnie i jesteś teraz gotowy, aby przejść na github. Możesz iść ze mną, jeśli chcesz

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

Teraz skonfiguruj to repozytorium, aby używać swojej tożsamości

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

Teraz dokonaj pierwszego zatwierdzenia

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

Sprawdź zatwierdzenie, aby zobaczyć, że nowa tożsamość została użyta za pomocą git log

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

W porządku, czas naciskać na github! Ponieważ github jeszcze nie wie o naszym nowym repozytorium, najpierw wejdź na github.com/new i utwórz nowe repozytorium - nazwij je kiedyś

Teraz, aby skonfigurować twoje repozytorium do „rozmowy” z github przy użyciu poprawnej tożsamości / poświadczeń, dodaliśmy pilota. Zakładając, że nazwa użytkownika github dla nowego konta to someuser...

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

Ta pogrubiona część jest absolutnie krytyczna i musi pasować do Hostzdefiniowanej w twoim ~/.ssh/configpliku

Na koniec wypchnij repozytorium

$ git push origin master

Zaktualizuj istniejące repozytorium, aby użyć nowej konfiguracji SSH

Załóżmy, że masz już kilka sklonowanych repozytoriów, ale teraz chcesz użyć nowej konfiguracji SSH. W powyższym przykładzie, my zachowaliśmy istniejące repo w takt przypisując poprzednią id_rsa/ id_rsa.pubpary kluczy do Host github.comzapisania w pliku konfiguracyjnym SSH. Nie ma w tym nic złego, ale mam teraz co najmniej 5 konfiguracji github i nie lubię myśleć o jednej z nich jako o konfiguracji „domyślnej” - wolałbym wyraźnie mówić o każdej z nich.

Zanim to mieliśmy

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

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

Zaktualizujemy to do tego (zmiany pogrubione )

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

Ale to oznacza, że ​​teraz żadne istniejące repo z github.compilotem nie będzie już działać z tym plikiem tożsamości. Ale nie martw się, to prosta poprawka.

Aby zaktualizować istniejące repozytorium w celu korzystania z nowej konfiguracji SSH, wystarczy otworzyć plik konfiguracyjny git repo i zaktualizować adres URL!

$ cd existingrepo
$ nano .git/config

Zaktualizuj pole zdalnego pochodzenia (zmiany pogrubione )

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

Otóż ​​to. Teraz możesz push/ pulldo zadowolenia swojego serca


Uprawnienia do pliku kluczy SSH

Jeśli masz problemy z nieprawidłowym działaniem kluczy publicznych, SSH ściśle przestrzega uprawnień do plików w ~/.sshkatalogu i odpowiednich plikach kluczy

Zasadniczo powinny istnieć wszystkie katalogi 700i wszystkie pliki 600- oznacza to, że są one tylko do odczytu / zapisu przez właściciela - żadna inna grupa / użytkownik nie może ich odczytać / zapisać

$ 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

Jak zarządzam kluczami SSH

Zarządzam osobnymi kluczami SSH dla każdego hosta, z którym się łączę, tak że jeśli jakiś klucz zostanie kiedykolwiek naruszony, nie muszę aktualizować kluczy w każdym innym miejscu, w którym użyłem tego klucza. To tak, jak gdy otrzymujesz powiadomienie od Adobe, że 150 milionów informacji o ich użytkownikach zostało skradzionych - teraz musisz anulować tę kartę kredytową i zaktualizować każdą zależną od niej usługę - co za uciążliwość.

Oto ~/.sshjak wygląda mój katalog: Mam jeden .pemklucz dla każdego użytkownika w folderze dla każdej domeny, z którą się łączę. Używam .pemkluczy, więc potrzebuję tylko jednego pliku na klucz.

$ 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

A oto mój odpowiedni /.ssh/configplik - oczywiście github ma znaczenie, aby odpowiedzieć na to pytanie dotyczące github, ale ta odpowiedź ma na celu wyposażyć cię w wiedzę na temat zarządzania twoją tożsamością ssh na dowolnej liczbie usług / maszyn.

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

Pobieranie klucza publicznego SSH z klucza PEM

Powyżej zauważyłeś, że dla każdego klucza mam tylko jeden plik. Kiedy muszę podać klucz publiczny, po prostu generuję go w razie potrzeby.

Więc kiedy github poprosi o klucz publiczny ssh, uruchom to polecenie, aby wypisać klucz publiczny na standardowe wyjście - skopiuj / wklej w razie potrzeby

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

Uwaga: jest to również ten sam proces, którego używam do dodawania mojego klucza do dowolnego zdalnego komputera. ssh-rsa AAAA...Wartość jest kopiowana do pilota ~/.ssh/authorized_keyspliku


Konwersja par id_rsa/ id_rsa.pubkluczy do formatu PEM

Więc chcesz oswoić swoje kluczowe pliki i ograniczyć niektóre cruft systemu plików? Przekształcenie pary kluczy w pojedynczy PEM jest łatwe

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

Lub, podążając za powyższymi przykładami, zmieniliśmy nazwę id_rsa -> github-mainuseri id_rsa.pub -> github-mainuser.pub- tak

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

Teraz, aby upewnić się, że przekonwertowaliśmy to poprawne, musisz sprawdzić, czy wygenerowany klucz publiczny pasuje do twojego starego klucza publicznego

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

Teraz, gdy masz już github-mainuser.pemplik, możesz bezpiecznie usunąć stary github-mainuseri github-mainuser.pubpliki - potrzebny jest tylko plik PEM; po prostu wygeneruj klucz publiczny, kiedy go potrzebujesz ^ _ ^


Tworzenie kluczy PEM od podstaw

Nie musisz tworzyć pary klucz prywatny / publiczny, a następnie konwertować na pojedynczy klucz PEM. Możesz utworzyć klucz PEM bezpośrednio.

Stwórzmy newuser.pem

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

Uzyskanie klucza publicznego SSH jest takie samo

$ ssh-keygen -y -f ~/.ssh/newuser.pem
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACA ... FUNZvoKPRQ==
Dziękuję Ci
źródło
1
Rozumiem, że to stare pytanie, ale to nie usprawiedliwia faktu, że prawie każda odpowiedź tutaj zależy od linku do jakiegoś samouczka, a zatem może ulec zepsuciu. Można łączyć źródła / cytowania, ale nie możesz opierać się na linku, jeśli nie streścisz najważniejszych fragmentów w zamieszczonej tutaj odpowiedzi.
Dziękuję
Poparłem twoją doskonałą i szczegółową odpowiedź, ponieważ jest to oczywiście właściwy sposób na zrobienie tego. Mój problem polega na tym, że jest złożony i po kilku latach korzystania z niektórych kont otrzymuję nowe, a potem nie mogę sobie przypomnieć, jak to zrobić „we właściwy sposób”. Moja droga poniżej jest bardzo prosta - po prostu tworzę 3 nowe pliki i jeden nowy skrypt i jestem gotowa. Przez wiele lat działał bez zarzutu. Czytelnicy mogą zdecydować, co będzie dla nich najlepsze.
David H
DavidH Doceniam uwagę. Odpowiedź wydaje się złożona, jeśli weźmiesz ją jako całość, ale czytelnik naprawdę musi tylko zająć się małą częścią odpowiedzi, jeśli ich jedynym celem jest dodanie jeszcze jednej tożsamości github - wszystkich pozostałych części odpowiedzi mają na celu stworzenie solidnego rozwiązania do zarządzania kluczami SSH w ogólności i są całkowicie opcjonalne.
Dziękuję
Myślę, że git clone github.com-otheruser:someorg/somerepo.gitmusi być git clone [email protected]:someorg/somerepo.git(dodanie git@). Leastways, właśnie tego potrzebowałem.
CommonsWare 30.01.2019
@CommonsWare wszystkie opcje wiersza poleceń, takie jak określenie użytkownika, można wykonać również w konfiguracji SSH. Na przykład: Host github.com(nowa linia) User git(nowa linia)IdentityFile ...
Dziękujemy
24

Tworząc różne aliasy hosta dla github.com w ~ / .ssh / config i nadając każdemu aliasowi hosta własny klucz ssh, możesz łatwo używać wielu kont github bez zamieszania. Wynika to z faktu, że github.com odróżnia nie użytkownika, który zawsze jest po prostu git, ale kluczem ssh, którego użyłeś do połączenia. Po prostu skonfiguruj swoje zdalne źródła za pomocą własnych aliasów hosta. ”

Powyższe streszczenie jest dzięki uprzejmości w komentarzach na blogu poniżej.

Uznałem to wyjaśnienie za najbardziej zrozumiałe. I działa dla mnie przynajmniej od kwietnia 2012 r.

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

Mishaba
źródło
1
Prawdopodobnie będziesz musiał także uruchomić $ ssh-add ~/.ssh/id_rsa_COMPANY- patrz Błąd: Odmowa zezwolenia (publickey) - Dokumentacja użytkownika
Pat
22

Szczegóły na stronie http://net.tutsplus.com/tutorials/tools-and-tips/how-to-work-with-github-and-multiple-accounts/ powiązane z mishaba działają dla mnie bardzo dobrze.

Z tej strony:

$ touch ~/.ssh/config

Następnie edytuj ten plik, aby był mniej więcej taki (jeden wpis na 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
Matthew Skelton
źródło
8
Chciałbym również zauważyć, że albo „github.com” albo „github-COMPANY” będą musiały być użyte podczas wykonywania klonowania (i prawdopodobnie innych poleceń), git clone git@github-COMPANY/repo/name.gitaby uzyskać właściwy klucz ssh.
hellatan
@dtan: Jak miałbym to wdrożyć, gdybym musiał sklonować https? git clone https://github-COMPANY/GitUserName/projectname.gitwydaje się nie działać. Domyślny klucz przy użyciu github.com działa dobrze.
Isaac Nequittepas
1
@IsaacRemuant, czy absolutnie musisz przejść przez https? Za każdym razem, gdy chcesz pociągnąć / popchnąć, musisz wprowadzić dane uwierzytelniające użytkownika. najlepiej byłoby zrobić git: //github-COMPANY...projectname.git. czy istnieje komunikat o błędzie dla połączenia https?
hellatan
@dtan: Mam pewne problemy z portem 22, mimo że najwyraźniej został dla mnie otwarty. ssh: connect to host github.com port 22: Bad file number fatal: The remote end hung up unexpectedly. Dotychczas jedynym sposobem był https. $ 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 Nie jestem pewien, czy może to być związane z plikiem konfiguracyjnym lub sposobem, w jaki próbuję emulować twoje połączenie git za pomocą https.
Isaac Nequittepas
Ostatecznie przeprowadzę dogłębną analizę, próbując wszystkiego i odpowiednio zamieszczę jako pytanie.
Isaac Nequittepas
13
  • Przejdź do ~ / .ssh
  • Utwórz plik o nazwie config (bez rozszerzenia)
  • Otwórz plik konfiguracyjny i dodaj poniższe kody. (zmień zgodnie z kontem)

    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
      
  • Dodaj zdalny adres URL w następujący sposób

    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
      

Upewnij się, że nazwy IdentityFile są takie same jak utworzone podczas generowania klucza ssh.

Pranav VR
źródło
Czy możesz wyjaśnić, dlaczego używasz PreferredAuthentications publickey?
Oliver Pearmain
@OliverPearmain Tutaj mówię ssh, że naszą preferowaną metodą uwierzytelniania jest publickey. Możesz użyć hasła w PreferredAuthentications, ale może być konieczne wprowadzenie hasła w celu uwierzytelnienia.
Pranav VR
1
Doceń odpowiedź @Pranav VR, brzmi jakbym chciał użyć tego samego :-)
Oliver Pearmain
11

Używam skryptów powłoki, aby przełączyć się na dowolne konto, które chcę być „aktywne”. Zasadniczo zaczynasz od początku, odpowiednio skonfigurujesz i działa jedno konto, a następnie przenieś te pliki do nazwy z odpowiednim prefiksem. Od tego momentu możesz używać polecenia „github” lub „gitxyz”, aby przełączać:

# 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

Miałem z tym wielkie szczęście. Stworzyłem również skrypt uruchamiania w Xcode (dla użytkowników komputerów Mac), aby nie budował mojego projektu, chyba że miałbym odpowiednie ustawienie (ponieważ używa git):

Uruchom skrypt umieszczony po zależnościach (używając / bin / ksh jako powłoki):

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

EDYCJA: dodano testy na obecność nowych plików i kopiowanie starych plików do / tmp w celu zajęcia się komentarzem @naomik poniżej.

David H.
źródło
Zachowaj ostrożność, publikując odpowiedzi na wiele pytań, kopiując i wklejając odpowiedzi na wiele pytań, które zazwyczaj są oznaczane przez społeczność jako „spam”. Jeśli to robisz, oznacza to zwykle, że pytania są duplikatami, więc oznacz je jako takie: stackoverflow.com/questions/7548158 , stackoverflow.com/questions/3225862 , stackoverflow.com/questions/7924937
Kev
1
To jest koszmar. Gdyby ktoś uruchomił ten skrypt, zanim zrozumie, że jego klucze id_rsai id_rsa.pubzostaną usunięte, mógłby zostać zablokowany z pilota.
Dziękuję
@naomik zaktualizował skrypt, aby najpierw sprawdzić nowe pliki i zapisać stare pliki w / tmp
David H
10

Ta odpowiedź jest dla początkujących (guru bez gitów) . Niedawno miałem ten problem i może to tylko ja, ale większość odpowiedzi wymagała wcześniejszego zrozumienia git. Po przeczytaniu kilku odpowiedzi na przepełnienie stosu, w tym tego wątku, oto kroki, które musiałem podjąć, aby łatwo przełączać się między kontami GitHub (np. Załóż dwa konta GitHub, github.com/personal i gitHub.com/work ):

  1. Sprawdź istniejące klucze ssh: Otwórz Terminal i uruchom to polecenie, aby zobaczyć / wyświetlić listę istniejącychls -al ~/.ssh
    plikówkluczy sshz rozszerzeniem.pubto klucze ssh, więc powinieneś mieć dwa dlakontpersonaliwork. Jeśli jest tylko jeden lub żaden, nadszedł czas, aby wygenerować inny mądry, pomiń to.

    - Generowanie klucza ssh : zaloguj się na github (osobisty lub służbowy), przejdź do Ustawień i skopiuj powiązany e-mail.
    teraz wróć do terminalu i uruchomssh-keygen -t rsa -C "the copied email", zobaczysz:

    Generowanie pary kluczy publiczny / prywatny rsa.
    Wprowadź plik, w którym chcesz zapisać klucz (/.../.ssh/id_rsa):
    jeśli generujesz dla konta służbowego. podaj hasło lub po prostu wpisz, aby zignorować, a przeczytasz coś takiego

    id_rsa jest domyślną nazwą dla wkrótce wygenerowanego klucza ssh, więc skopiuj ścieżkę i zmień nazwę domyślną, np. /.../.ssh/id_rsa_workObraz losowy klucza to: i obraz. gotowy.
    Powtórz ten krok jeszcze raz dla drugiego konta github. Upewnij się, że używasz prawidłowego adresu e-mail i innej nazwy klucza ssh (np. Id_rsa_personal), aby uniknąć zastąpienia.
    Na tym etapie powinieneś zobaczyć dwa klucze ssh przy ls -al ~/.sshponownym uruchomieniu .
  2. Powiąż klucz ssh z kontem gitHub: Kolejnym krokiem jest skopiowanie jednego z kluczy ssh, uruchom to, ale zastępując własną nazwę klucza ssh: pbcopy < ~/.ssh/id_rsa_work.pubzamień na id_rsa_work.pubto, co nazywasz swoim.
    Teraz, gdy nasz klucz ssh jest kopiowany do schowka, wróć do konta github [upewnij się, że jesteś zalogowany do konta działać, jeśli klucz ssh skopiowany jest id_rsa_work] i przejdź do
    Ustawienia - SSH i klucze GPG i kliknij na klucz New SSH przycisku (nie nowy klucz GPG btw: D)
    podaj tytuł tego klucza, wklej klucz i kliknij Dodaj klucz SSH. Teraz pomyślnie dodałeś klucz ssh lub zauważyłeś, że był tam cały czas, co jest w porządku (lub wystąpił błąd, ponieważ wybrałeś Nowy klucz GPG zamiastNowy klucz SSH : D).
  3. Powiąż klucz ssh z kontem gitHub : Powtórz powyższy krok dla drugiego konta.
  4. Edytuj globalną konfigurację git: Ostatnim krokiem jest upewnienie się, że globalny plik konfiguracyjny jest świadomy wszystkich kont github (że tak powiem).
    Uruchom, git config --global --editaby edytować ten plik globalny, jeśli otworzy się vim i nie wiesz, jak go używać, naciśnij, iaby przejść do trybu wstawiania, edytuj plik jak poniżej i naciśnij klawisz esc, a następnie, :wqaby wyjść z trybu wstawiania:

    [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

Gotowe !, teraz, gdy próbujesz wypchnąć lub wyciągnąć z repozytorium, zostaniesz zapytany, które konto GitHub powinno być połączone z tym repozytorium, a jego pytanie zostanie zadane tylko raz, konfiguracja lokalna zapamięta ten link, a nie konfigurację globalną, abyś mógł pracować na różnych repozytoriach powiązanych z różnymi kontami bez konieczności każdorazowej edycji konfiguracji globalnej.

Lukas
źródło
Powinny zezwalać na tagi dla odpowiedzi, dotyczy to Mac OS.
user4015990,
5

Prostsza i łatwa naprawa, aby uniknąć nieporozumień ..

Użytkownicy systemu Windows mogą korzystać z wielu lub różnych kont git dla różnych projektów.

Następujące kroki: Przejdź do Panelu sterowania i wyszukaj Credential Manager. Następnie przejdź do Credential Manager -> Poświadczenia systemu Windows

Teraz usuń węzeł git: https // github.com w sekcji Nagłówki poświadczeń ogólnych

Spowoduje to usunięcie bieżących poświadczeń. Teraz możesz dodać dowolny projekt poprzez git pull, poprosi on o nazwę użytkownika i hasło.

W przypadku problemów z innym kontem wykonaj ten sam proces.

Dzięki

odnoszą się do obrazu

Raja Shakir
źródło
4

właśnie wymyśliłem to dla systemu Windows, używając poświadczeń dla każdego repozytorium:

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 referencji. https://github.com . informuje pomocnika referencji o adresie URL referencji. „UseHttpPath” mówi menedżerowi poświadczeń, aby użył ścieżki do poświadczenia. Jeśli parametr useHttpPath zostanie pominięty, menedżer poświadczeń zapisze jedno poświadczenie dla https://github.com . Jeśli zostanie uwzględniony, menedżer poświadczeń będzie przechowywać wiele poświadczeń, czego naprawdę chciałem.

Craig - MSFT
źródło
2

Oprócz tworzenia wielu kluczy SSH dla wielu kont możesz również rozważyć dodanie współpracowników do każdego projektu przy użyciu tego samego adresu e-mail konta i przechowywanie hasła na stałe.

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

Skonfigurowałem wiele kont z różnymi wiadomościami e-mail, a następnie umieściłem tego samego użytkownika i wiadomość e-mail na każdym koncie jako jeden ze współpracowników. W ten sposób mogę uzyskać dostęp do wszystkich kont bez dodawania klucza SSH lub przełączania się na inną nazwę użytkownika i e-mail w celu uwierzytelnienia.

Chetabahana
źródło
2

Najłatwiejsze i najprostsze podejście (IMHO) - bez problemów z plikami konfiguracyjnymi

Po prostu utwórz kolejny klucz ssh.

Załóżmy, że masz nowe robocze konto GitHub, po prostu utwórz dla niego nowy klucz:

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

Teraz powinieneś mieć starą i nową, aby je zobaczyć, uruchom:

ls -al ~/.ssh

Musisz uruchomić powyższe tylko raz.

Od teraz za każdym razem, gdy chcesz przełączać się między nimi, po prostu uruchom:

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

Aby przełączyć się na stary, uruchom ponownie:

 ssh-add -D
 ssh-add ~/.ssh/<previous id_rsa>
Kohn1001
źródło
1

innym łatwiejszym sposobem jest używanie wielu aplikacji komputerowych, takich jak to, co robię, korzystanie z konta A na komputerze Github, podczas korzystania z konta B na Github Kraken

Jet Yu
źródło
1

Jeśli nie chcesz zadzierać z ~/.ssh/config plikiem wymienionym tutaj, możesz zamiast tego uruchomić git config core.sshCommand "ssh -i ~/.ssh/custom_id_rsa"repozytorium, w którym chcesz zatwierdzić z innego konta.

Reszta konfiguracji jest taka sama:

  1. Utwórz nowy klucz SSH dla drugiego konta za pomocą ssh-keygen -t rsa -f ~/.ssh -f ~/.ssh/custom_id_rsa

  2. Zaloguj się do github przy użyciu drugiego konta, przejdź do https://github.com/settings/keys i wklej zawartość~/.ssh/custom_id_rsa.pub

  3. Upewnij się, że używasz SSH zamiast HTTPS jako zdalnego adresu URL: git remote set-url origin [email protected]:upstream_project_teamname/upstream_project.git

thakis
źródło
0

W przeciwieństwie do innych odpowiedzi, w których musisz wykonać kilka kroków, aby użyć dwóch różnych kont github z tej samej maszyny, dla mnie to działało dwóch krokach .

Musisz tylko:

1) wygeneruj parę kluczy publicznych i prywatnych SSH dla każdego konta na koncie~/.ssh lokalizacji o różnych nazwach i

2) dodaj wygenerowane klucze publiczne do odpowiedniego konta w Settings>> SSH and GPG keys>>New SSH Key .

Aby wygenerować pary kluczy publicznych i prywatnych SSH, użyj następującego polecenia:

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

W wyniku powyższych poleceń id_rsa_WORKi id_rsa_WORK.pubpliki zostaną utworzone dla twojego konta służbowego (ex - git.work.com) id_rsa_PERSONALi id_rsa_PERSONAL.pubzostaną utworzone dla twojego konta osobistego (ex - github.com).

Po utworzeniu skopiuj treść z każdego publicznego (*.pub pliku ) i wykonaj krok 2 dla każdego konta.

PS : Nie ma potrzeby wprowadzania wpisu hosta dla każdego konta git w ~/.ssh/configpliku, jak wspomniano w innych odpowiedziach, jeśli nazwa hosta dwóch kont jest inna.

Sahil Chhabra
źródło
Jak przełączasz się między dwoma kontami na komputerze lokalnym?
user4015990,
1
Nie ma potrzeby zmiany. Ilekroć sklonujesz repo w lokalnym, informacje o koncie będą zapisywane przez git w twoim lokalnym repo. Tak więc za każdym razem, gdy wykonasz polecenie git push lub pull wewnątrz tego lokalnego repozytorium, powyższa konfiguracja wykryje, które konto rozważyć.
Sahil Chhabra
0

Jeśli akurat masz zainstalowany WSL , możesz mieć dwa osobne konta git - jedno w WSL i jedno w Windows.

Almenon
źródło
0

Powinieneś i nie wolno naciskać na projekt przy użyciu niektórych wspólnych poświadczeń. Po uruchomieniu na nowym komputerze wykonaj następujące czynności, aby skonfigurować i poprawnie użyć danych logowania gitlab:

  • utwórz klucze ssh łonowe / prywatne na maszynie
  • skopiuj wklej klucz publiczny do interfejsu gitlab / github ui (każdy, kto podpowiada, jak to zrobić przez linię cmd, dostaje darmowe piwo ...)
  • upewnij się, że klonujesz repo za pomocą git, a nie adresu URL http
  • ustaw alias git, aby uniknąć ciągłego wpisywania tego samego przedrostka w poleceniu git
  • podczas git commit ZAWSZE używaj flag autora i e-mail
  • użyj git jak zwykle byś to zrobił

Wszystko to w następujący sposób:

 # 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 [email protected]: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 <[email protected]>"

 # use git as normal
 git fetch --all; git pull --all 
Yordan Georgiev
źródło
0
  1. Przejdź do katalogu, w którym chcesz przekazać zmiany na inne konto GitHub.
  2. Utwórz nowy klucz SSH w swoim terminalu / wierszu poleceń.

    ssh-keygen -t rsa -C „Twój adres e-mail”

  3. Wyświetlone zostaną następujące informacje:

    Generowanie publicznej / prywatnej pary kluczy rsa. Wprowadź plik, w którym chcesz zapisać klucz (/home/your_username/.ssh/id_rsa):

Skopiuj i wklej ścieżkę, a następnie identyfikowalną nazwę pliku:

/home/your_username/.ssh/id_rsa_personal

4) Następnie poprosi Cię o:

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

5) Możesz teraz wpisać następujące polecenie, aby wyświetlić wszystkie klucze SSH, które masz na komputerze lokalnym:

ls -al ~/.ssh

Powinieneś być w stanie zobaczyć nowy plik klucza SSH. Jak widać w moim, mam zarówno id_rsa_test, jak i 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) Następnie musisz skopiować klucz SSH, który jest przechowywany w pliku id_rsa_personal.pub. Możesz otworzyć to w dowolnym edytorze tekstu. Obecnie używam atomu, więc otworzyłem plik za pomocą następującego polecenia:

atom ~/.ssh/id_rsa_personal.pub

Otrzymasz wtedy coś podobnego do tego:

ssh-rsa AAB3HKJLKC1yc2EAAAADAQABAAABAQCgU5 + ELtwsKkmcoeF3hNd7d6CjW + dWut83R / Dc01E / YzLc5ZFri18doOwuQoeTPpmIRVDGuQQWWGMMrrrv5 MWXMMrrva

7) Skopiuj to i przejdź do konta GitHub → Ustawienia → Klucze SSH i GPG 8) Kliknij Nowy klucz SSH. Skopiuj klucz, nadaj mu tytuł i dodaj go. 9) Dodaj klucz z terminala

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

10) Skonfiguruj użytkownika i hasło.

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

11) Jesteśmy gotowi do zatwierdzenia i pchnięcia już teraz.

git init
git add .
git commit 
git push
Shreya Sharma
źródło
0

Jeśli utworzyłeś lub sklonowałeś inne repozytorium i nie możesz pobrać z originlubupstream dodać klucza ssh w tym katalogu przy użyciu następującego polecenia, działało.

Oto błąd, który tu otrzymałem:

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

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

Użyłem następującego polecenia, to działa:

ssh-add ~/.ssh/id_rsa_YOUR_COMPANY_NAME

Rishi Raj
źródło