sshma -iopcję określenia, którego pliku klucza prywatnego użyć podczas uwierzytelniania:

-i identity_file

Wybiera plik, z którego odczytywana jest tożsamość (klucz prywatny) dla uwierzytelnienia RSA lub DSA. Domyślną wartością jest ~/.ssh/identitydla protokołu w wersji 1, a ~/.ssh/id_rsai ~/.ssh/id_dsadla wersji protokołu 2. Pliki tożsamości może być również określona na zasadzie per-host w pliku konfiguracyjnym. Możliwe jest posiadanie wielu -iopcji (i wielu tożsamości określonych w plikach konfiguracyjnych).

Czy istnieje podobny sposób na określenie, gitktórego pliku klucza prywatnego użyć w systemie z wieloma kluczami prywatnymi w ~/.sshkatalogu?

W ~/.ssh/configdodaj:

host github.com
 HostName github.com
 IdentityFile ~/.ssh/id_rsa_github
 User git

Teraz możesz zrobić git clone [email protected]:username/repo.git.

UWAGA: Sprawdź, czy uprawnienia do IdentityFile wynoszą 400. SSH odrzuci, w sposób nieokreślony, klucze SSH, które są zbyt czytelne. Będzie to wyglądało jak odrzucenie poświadczenia. Rozwiązaniem w tym przypadku jest:

chmod 400 ~/.ssh/id_rsa_github

Zmienna środowiskowa GIT_SSH_COMMAND:

Z Gita w wersji 2.3.0 możesz używać zmiennej środowiskowej w GIT_SSH_COMMANDnastępujący sposób:

GIT_SSH_COMMAND="ssh -i ~/.ssh/id_rsa_example" git clone example

Pamiętaj, że -iczasem plik konfiguracyjny może go zastąpić. W takim przypadku należy podać SSH pusty plik konfiguracyjny, taki jak ten:

GIT_SSH_COMMAND="ssh -i ~/.ssh/id_rsa_example -F /dev/null" git clone example

Konfiguracja core.sshCommand:

W Git w wersji 2.10.0 możesz to skonfigurować na repo lub globalnie, więc nie musisz już ustawiać zmiennej środowiskowej!

git config core.sshCommand "ssh -i ~/.ssh/id_rsa_example -F /dev/null"
git pull
git push

Nie ma bezpośredniego sposobu na określenie, gitktórego klucza prywatnego użyć, ponieważ polega on sshna uwierzytelnianiu repozytorium. Istnieje jednak kilka sposobów na osiągnięcie celu:

Opcja 1: ssh-agent

Możesz użyć ssh-agentdo tymczasowej autoryzacji swojego klucza prywatnego.

Na przykład:

$ ssh-agent sh -c 'ssh-add ~/.ssh/id_rsa; git fetch user@host'

Opcja 2: GIT_SSH_COMMAND

Przekaż argumenty ssh przy użyciu GIT_SSH_COMMANDzmiennej środowiskowej (Git 2.3.0+).

Na przykład:

$ GIT_SSH_COMMAND='ssh -i ~/.ssh/id_rsa -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no' \
  git clone user@host

_{Możesz wpisać to wszystko w jednym wierszu - zignoruj $i pomiń \.}

Opcja 3: GIT_SSH

Przekaż argumenty ssh za pomocą GIT_SSHzmiennej środowiskowej, aby określić alternatywny sshplik binarny.

Na przykład:

$ echo 'ssh -i ~/.ssh/id_rsa -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no $*' > ssh
$ chmod +x ssh
$ GIT_TRACE=1 GIT_SSH='./ssh' git clone user@host

_{Uwaga: powyższe linie to wiersze poleceń powłoki (terminala), które należy wkleić do terminala. Utworzą plik o nazwie ssh, sprawią, że będzie wykonywalny i (pośrednio) go uruchomią.}

^{Uwaga: GIT_SSHjest dostępny od wersji 0.9.4 (2005).}

Opcja 4: ~/.ssh/config

Użyj ~/.ssh/configpliku zgodnie z sugestią zawartą w innych odpowiedziach, aby określić lokalizację klucza prywatnego, np

Host github.com
  User git
  Hostname github.com
  IdentityFile ~/.ssh/id_rsa

Napisz skrypt, który wywołuje sshżądane argumenty, i umieść w nim nazwę pliku skryptu $GIT_SSH. Lub po prostu wprowadź swoją konfigurację ~/.ssh/config.

Jeśli nie chcesz określać zmiennych środowiskowych za każdym razem, gdy uruchamiasz git, nie chcesz innego skryptu opakowania, nie uruchamiaj / nie możesz uruchomić ssh-agent (1), ani nie chcesz pobierać innego pakietu tylko do tego celu, użyj git -remote-ext (1) transport zewnętrzny:

$ git clone 'ext::ssh -i $HOME/.ssh/alternate_id git.example.com %S /path/to/repository.git'
Cloning into 'repository'
(...)
$ cd repository
$ git remote -v
origin  ext::ssh -i $HOME/.ssh/alternate_id git.example.com %S /path/to/repository.git (fetch)
origin  ext::ssh -i $HOME/.ssh/alternate_id git.example.com %S /path/to/repository.git (push)

Uważam to rozwiązanie za lepsze, ponieważ:

• Jest to specyficzne dla repozytorium / zdalnego
• Unikaj wzdęcia skryptu opakowania
• Nie potrzebujesz agenta SSH - przydatne, jeśli chcesz bezobsługowych klonów / push / pullów (np. W cronie)
• Zdecydowanie nie potrzeba zewnętrznego narzędzia

Użyj niestandardowej konfiguracji hosta w ~/.ssh/confignastępujący sposób:

Host gitlab-as-thuc  
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_rsa.thuc
    IdentitiesOnly yes

użyj niestandardowej nazwy hosta w ten sposób:

git remote add thuc git@gitlab-as-thuc:your-repo.git  

Po moich zmaganiach $GIT_SSHchciałbym podzielić się tym, co dla mnie zadziałało.

Poprzez moje przykłady założę, że masz swój prywatny klucz na/home/user/.ssh/jenkins

Błąd, którego należy unikać: wartość GIT_SSH obejmuje opcje

$ export GIT_SSH="ssh -i /home/user/.ssh/jenkins"

lub cokolwiek podobnego zawiedzie, ponieważ git spróbuje wykonać wartość jako plik . Z tego powodu musisz utworzyć skrypt.

Przykład roboczy skryptu $ GIT_SSH /home/user/gssh.sh

Skrypt zostanie wywołany w następujący sposób:

$ $GIT_SSH [username@]host [-p <port>] <command>

Przykładowy działający skrypt może wyglądać następująco:

#!/bin/sh
ssh -i /home/user/.ssh/jenkins $*

Zwróć uwagę $*na koniec, jest to ważna jego część.

Jeszcze bezpieczniejszą alternatywą, która zapobiegłaby wszelkim możliwym konfliktom z czymkolwiek w domyślnym pliku konfiguracyjnym (oraz wyraźnym wskazaniem portu, którego należy użyć) byłoby:

#!/bin/sh
ssh -i /home/user/.ssh/jenkins -F /dev/null -p 22 $*

Zakładając, że skrypt jest włączony /home/user/gssh.sh, należy:

$ export GIT_SSH=/home/user/gssh.sh

i wszystko zadziała.

Możesz po prostu użyć ssh-ident zamiast tworzyć własne opakowanie.

Możesz przeczytać więcej na: https://github.com/ccontavalli/ssh-ident

Ładuje klucze ssh na żądanie, gdy są potrzebne po raz pierwszy, nawet przy wielu sesjach logowania, xterms lub współdzielonych domach NFS.

Mały plik konfiguracyjny umożliwia automatyczne ładowanie różnych kluczy i oddzielanie ich w różnych agentach (do przekazywania agentów) w zależności od tego, co musisz zrobić.

Miałem klienta, który potrzebował osobnego konta github. Musiałem więc użyć osobnego klucza tylko do tego jednego projektu.

Moim rozwiązaniem było dodanie tego do mojego .zshrc / .bashrc:

alias infogit="GIT_SSH_COMMAND=\"ssh -i ~/.ssh/id_specialkey\" git $@"

Ilekroć chcę użyć git dla tego projektu, zastępuję „infogit” git:

infogit commit -am "Some message" && infogit push

Dla mnie łatwiej jest zapamiętać.

Ustawiłem więc zmienną env GIT_SSH na $HOME/bin/git-ssh.

Aby wesprzeć konfigurację mojego repozytorium, która tożsamość ssh ma być używana, mój ~/bin/git-sshplik jest następujący:

#!/bin/sh
ssh -i $(git config --get ssh.identity) -F /dev/null -p 22 $*

Następnie mam globalne ustawienie konfiguracji git:

$ git config --global ssh.identity ~/.ssh/default_id_rsa

I w dowolnym repozytorium git mogę po prostu ustawić lokalną ssh.identitywartość konfiguracji git:

$ git config --local ssh.identity ~/.ssh/any_other_id_rsa

Voila!

Jeśli możesz mieć inny adres e-mail dla każdej tożsamości, staje się to jeszcze prostsze, ponieważ możesz po prostu nazwać swoje klucze po adresach e-mail, a następnie poprosić użytkownika user gain config. E-mail steruje wyborem klucza w następujący sposób ~/bin/git-ssh:

#!/bin/sh
ssh -i $HOME/.ssh/$(git config --get user.email) -F /dev/null -p 22 $*

Moje rozwiązanie było następujące:

utwórz skrypt:

#!/bin/bash
KEY=dafault_key_to_be_used
PORT=10022 #default port...
for i in $@;do
   case $i in
    --port=*)
        PORT="${i:7}";;
    --key=*)KEY="${i:6}";;
   esac
done
export GIT_SSH_COMMAND="ssh -i $HOME/.ssh/${KEY} -p ${PORT}"
echo Command: $GIT_SSH_COMMAND

wtedy, gdy musisz zmienić var ​​run:

. ./thescript.sh [--port=] [--key=]

Nie zapomnij o dodatkowej kropce !! to sprawia, że ​​skrypt ustawia zmienne środowisk !! --key i --port są opcjonalne.

Zasadniczo chcesz do tego użyć ~/.ssh/config. Po prostu sparuj adresy serwerów z kluczami, których chcesz użyć w następujący sposób:

Host github.com
  IdentityFile ~/.ssh/id_rsa.github
Host heroku.com
  IdentityFile ~/.ssh/id_rsa.heroku
Host *
  IdentityFile ~/.ssh/id_rsa

Host *oznacza dowolny serwer, więc używam go ~/.ssh/id_rsajako domyślnego klucza do użycia.

Buduję na @shellholic i tym wątku SO z kilkoma teakami. Używam GitHub jako przykładu i zakładam, że masz klucz prywatny ~/.ssh/github(w przeciwnym razie zobacz ten wątek SO ) i że dodałeś klucz publiczny do swojego profilu GitHub (w przeciwnym razie zobacz pomoc GitHub ).

W razie potrzeby utwórz nowy plik konfiguracyjny SSH ~/.ssh/configi zmień uprawnienia na 400

touch ~/.ssh/config
chmod 600 ~/.ssh/config

Dodaj to do ~/.ssh/configpliku:

Host github.com
    IdentityFile ~/.ssh/github
    IdentitiesOnly yes

Jeśli masz już zdalną konfigurację, możesz ją usunąć, w przeciwnym razie nadal możesz zostać poproszony o podanie nazwy użytkownika i hasła:

git remote rm origin

Następnie dodaj zdalny do repozytorium git i zauważ dwukropek przed nazwą użytkownika:

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

A następnie polecenia git działają normalnie, np .:

git push origin master
git pull origin 

@HeyWatch W tym wątku SO sugerowano dodanie, IdentitiesOnly yesaby zapobiec domyślnemu zachowaniu SSH wysyłania pliku tożsamości pasującego do domyślnej nazwy pliku dla każdego protokołu. Zobacz ten wątek, aby uzyskać więcej informacji i referencje.

Wystarczy użyć ssh-agenti ssh-addpoleceń.

# create an agent
ssh-agent

# add your default key
ssh-add ~/.ssh/id_rsa

# add your second key
ssh-add ~/.ssh/<your key name>

Po wykonaniu powyższych poleceń możesz używać obu klawiszy jednocześnie. Po prostu wpisz

git clone [email protected]:<yourname>/<your-repo>.git

sklonować swoje repozytorium.

Musisz wykonać powyższe polecenie po ponownym uruchomieniu komputera.

Używam gita w wersji 2.16 i nie potrzebuję ani jednego skryptu, nawet konfiguracji lub zmodyfikowanych poleceń.

• Właśnie skopiowałem mój klucz prywatny do .ssh / id_rsa
• ustaw uprawnienia na 600

I git automatycznie czyta klucz. Nic nie pytam i nie rzuca błędu. Po prostu działa dobrze.

Chociaż pytanie nie wymaga tego, zamieszczam tę odpowiedź dla każdego, kto chce rozwiązać ten sam problem tylko dla gitlab .

Rozwiązanie gitlab

Próbowałem użyć podejścia do zmiennych środowiskowych , ale nawet dokumentacja git zaleca używanie ~/.ssh/configczegoś więcej niż prostego przypadku. W moim przypadku pcham na serwer gitlab - i chciałem to zrobić jako określony użytkownik - który jest oczywiście definiowany przez klucz prywatny podczas uwierzytelniania, a nie nazwę użytkownika git. Po wdrożeniu po prostu wykonuję następujące czynności:

~/myrepo> git mycommit -m "Important Stuff"
~/myrepo> git mypush
[proceed to enter passphrase for private key...]

Ustawiać

Przypomnij sobie lokalizację twojego klucza prywatnego /myfolder/.ssh/my_gitlab_id_rsa w moim przypadku.

Dodaj wpis w ~/.ssh/config:

Host gitlab-delegate
    HostName gitlab.mydomain.com
    User git
    IdentityFile /myfolder/.ssh/my_gitlab_id_rsa
    IdentitiesOnly yes

Dodaj alias git w ~/.gitconfig:

mypush = "!f() { \
           path=$(git config --get remote.origin.url | cut -d':' -f2); \
           branch=$(git rev-parse --abbrev-ref HEAD); \
           git remote add gitlab_as_me git@gitlab-delegate:$path && \
           git push gitlab_as_me $branch && \
           git pull origin $branch; \
           git remote remove gitlab_as_me; \
         }; f"

Jako bonus wykonuję swoje zatwierdzenia na tym samym hoście jako określony użytkownik za pomocą tego aliasu git :

mycommit = "!f() { \
             git -c "user.name=myname" -c "[email protected]" commit \"$@\"; \
           }; f"

Wyjaśnienie

Wszystkie powyższe zakłada, że ​​odpowiedni pilot jest, origina odpowiedni oddział jest obecnie sprawdzony. W celach informacyjnych natknąłem się na kilka elementów, które należało rozwiązać:

• Rozwiązanie wymaga utworzenia nowego pilota gitlab_as_mei nie podobało mi się widzenie dodatkowego pilota wiszącego w moim drzewie dziennika, więc usuwam go po zakończeniu
• Aby utworzyć pilota, trzeba wygenerować adres URL pilota w locie - w przypadku gitlab zostało to osiągnięte za pomocą prostego cięcia bash
• Wykonując push do gitlab_as_me, musisz dokładnie określić, którą gałąź naciskasz
• Po wykonaniu wypychania originwskaźnik lokalny musi zostać „zaktualizowany” w celu dopasowania gitlab_as_me( git pull origin $branchrobi to)

Jeśli masz wiele kont git i chcesz mieć inny klucz ssh

Musisz wykonać ten sam krok, aby wygenerować klucz ssh, ale upewnij się, że tak

ssh-keygen -t ed25519 -C "[email protected]" 

Wprowadź ścieżkę, którą chcesz zapisać (np. My-pc / Desktop / .ssh / ed25519)

Dodaj klucz publiczny do gitlab ( Jak dodać klucz ssh do gitlab )

Musisz do nowej tożsamości ssh za pomocą poniższego polecenia

ssh-add ~/my-pc/Desktop/.ssh/ed25519

    # start :: how-to use different ssh identity files

    # create the company identity file
    ssh-keygen -t rsa -b 4096 -C "[email protected]"
    # save private key to ~/.ssh/id_rsa.corp, 
    cat ~/.ssh/id_rsa.corp.pub # copy paste this string into your corp web ui security ssh keys

    # create your private identify file
    ssh-keygen -t rsa -b 4096 -C "[email protected]"
    # save private key to ~/.ssh/id_rsa.me, note the public key ~/.ssh/id_rsa.me.pub
    cat ~/.ssh/id_rsa.me.pub # copy paste this one into your githubs, private keys

    # clone company internal repo as follows
    GIT_SSH_COMMAND="ssh -i ~/.ssh/id_rsa.corp -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no" \
    git clone [email protected]:corp/project.git

    export git_msg="my commit msg with my corporate identity, explicitly provide author"
    git add --all ; git commit -m "$git_msg" --author "MeFirst MeLast <[email protected]>"
    GIT_SSH_COMMAND="ssh -i ~/.ssh/id_rsa.corp -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no" \
    git push 
    # and verify 
    clear ; git log --pretty --format='%h %ae %<(15)%an ::: %s

    # clone public repo as follows
    GIT_SSH_COMMAND="ssh -i ~/.ssh/id_rsa.corp -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no" \
    git clone [email protected]:acoolprojectowner/coolproject.git

    export git_msg="my commit msg with my personal identity, again author "
    git add --all ; git commit -m "$git_msg" --author "MeFirst MeLast <[email protected]>"
    GIT_SSH_COMMAND="ssh -i ~/.ssh/id_rsa.me -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no" \
    git push ; 
    # and verify 
    clear ; git log --pretty --format='%h %ae %<(15)%an ::: %s

    # stop :: how-to use different ssh identity files