Wiele kont github na tym samym komputerze?

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?

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

• Ten link jest łatwy do naśladowania (Dzięki Eric): http://code.tutsplus.com/tutorials/quick-tip-how-to-work-with-github-and-multiple-accounts--net-22574

• Generowanie kluczy SSH (Win / msysgit) https://help.github.com/articles/generating-an-ssh-key/

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 = defaultemail@gmail.com

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

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

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

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

Użyj HTTPS:

zmień zdalny adres URL na https:

git remote set-url origin https://USERNAME@github.com/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 USERNAME@example.com

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 "someuser@some.org"

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

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/

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

• 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 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
     

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

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.

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.

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

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://USERNAME@github.com/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.

Uważam, że ten klejnot jest bardzo przydatny: sshwitch

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

Pomaga zmienić klucze ssh. Pamiętaj, aby najpierw wykonać kopię zapasową wszystkiego!

Ponadto, aby upewnić się, że commity mają poprawny adres e-mail, upewniłem się, że plik ~ / .gitconfig ma prawidłowy adres e-mail.

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.

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>

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

IntelliJ Idea ma wbudowaną obsługę tego https://www.jetbrains.com/help/idea/github.html#da8d32ae

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 git@github.com:upstream_project_teamname/upstream_project.git

Nie musisz utrzymywać dwóch różnych kont osobistych i służbowych. W rzeczywistości Github zaleca prowadzenie jednego konta i pomaga połączyć oba.

Kliknij poniższy link, aby połączyć, jeśli uznasz, że nie musisz utrzymywać wielu kont.

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

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@work.com" -f "id_rsa_WORK"
ssh-keygen -t rsa -C "email@gmail.com" -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.

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

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 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. 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

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