Jak określić prywatny klucz SSH do użycia podczas wykonywania polecenia powłoki w Git?

Może to dość nietypowa sytuacja, ale chcę określić prywatny klucz SSH, który będzie używany podczas wykonywania polecenia powłoki (git) z komputera lokalnego.

Zasadniczo tak:

git clone git@github.com:TheUser/TheProject.git -key "/home/christoffer/ssh_keys/theuser"

Lub nawet lepiej (w Ruby):

with_key("/home/christoffer/ssh_keys/theuser") do
  sh("git clone git@github.com:TheUser/TheProject.git")
end

Widziałem przykłady łączenia się ze zdalnym serwerem za pomocą Net :: SSH, który używa określonego klucza prywatnego, ale jest to polecenie lokalne. Czy to możliwe?

Coś takiego powinno działać (sugerowane przez orip):

ssh-agent bash -c 'ssh-add /somewhere/yourkey; git clone git@github.com:user/project.git'

jeśli wolisz podpowłoki, możesz wypróbować następujące (choć jest to bardziej delikatne):

ssh-agent $(ssh-add /somewhere/yourkey; git clone git@github.com:user/project.git)

Git wywoła SSH, który znajdzie swojego agenta według zmiennej środowiskowej; to z kolei spowoduje załadowanie klucza.

Alternatywnie, ustawienie HOMEmoże również załatwić sprawę, pod warunkiem, że chcesz skonfigurować katalog, który zawiera tylko .sshkatalog as HOME; może to zawierać plik tożsamości.pub lub plik konfiguracyjny IdentityFile.

Żadne z tych rozwiązań nie działało dla mnie.

Zamiast tego omawiam wzmiankę o @Martin v. Löwis o ustawianiu configpliku dla SSH.

SSH wyszuka ~/.ssh/configplik użytkownika . Mam swoją konfigurację jako:

Host gitserv
    Hostname remote.server.com
    IdentityFile ~/.ssh/id_rsa.github
    IdentitiesOnly yes # see NOTES below

I dodaję zdalne repozytorium git:

git remote add origin git@gitserv:myrepo.git

A potem polecenia git działają dla mnie normalnie.

git push -v origin master

UWAGI

• Jest IdentitiesOnly yesto konieczne, aby zapobiec domyślnemu zachowaniu SSH wysyłania pliku tożsamości zgodnego z domyślną nazwą pliku dla każdego protokołu. Jeśli masz plik o nazwie, ~/.ssh/id_rsaktóry zostanie wypróbowany PRZED twoją ~/.ssh/id_rsa.githubbez tej opcji.

Bibliografia

• Najlepszy sposób na użycie wielu kluczy prywatnych SSH na jednym kliencie
• Jak mogłem przestać ssh oferować zły klucz

Począwszy od Gita 2.3.0 mamy również proste polecenie (nie wymaga pliku konfiguracyjnego):

GIT_SSH_COMMAND='ssh -i private_key_file' git clone user@host:repo.git

Sugestie innych osób ~/.ssh/configsą bardzo skomplikowane. Może to być tak proste, jak:

Host github.com
  IdentityFile ~/.ssh/github_rsa

Zawartość my_git_ssh_wrapper:

#!/bin/bash

ssh -i /path/to/ssh/secret/key $1 $2

Następnie możesz użyć klucza, wykonując:

GIT_SSH=my_git_ssh_wrapper git clone git@github.com:TheUser/TheProject.git

Z git 2.10+ (Q3 2016: zwolniony września 2d, 2016), masz możliwość, aby ustawić config dla GIT_SSH_COMMAND(i nie tylko zmienną środowiskową jak opisano w Rober Jack „s odpowiedzi )

Zobacz commit 3c8ede3 (26 czerwca 2016 r.) Autor: Nguyễn Thái Ngọc Duy ( pclouds) .
^{(Połączone przez Junio ​​C Hamano - gitster- w commit dc21164 , 19 lipca 2016)}

Dodano nową zmienną konfiguracyjną, core.sshCommandaby określić, jakiej wartości GIT_SSH_COMMANDnależy użyć na repozytorium.

core.sshCommand:

Jeśli ta zmienna jest ustawiona git fetchi git pushużyje określonej komendy zamiast tego, sshkiedy będą musiały połączyć się ze zdalnym systemem.
Polecenie ma taką samą formę jak GIT_SSH_COMMANDzmienna środowiskowa i jest zastępowane, gdy zmienna środowiskowa jest ustawiona.

Oznacza to, że git clonemogą być:

cd /path/to/my/repo
git config core.sshCommand 'ssh -i private_key_file' 
# later on
git clone host:repo.git

Możesz nawet ustawić tylko jedną komendę:

git -c core.sshCommand="ssh -i private_key_file" clone host:repo.git

Jest to łatwiejsze niż ustawienie GIT_SSH_COMMANDzmiennej środowiskowej, która w systemie Windows, jak zauważył przez Mátyás Kuti-Kreszács byłoby

set "GIT_SSH_COMMAND=ssh -i private_key_file"

Podsumowując odpowiedzi i komentarze , najlepszym sposobem na skonfigurowanie gita do używania różnych plików kluczy, a następnie zapomnienie o nim, który obsługuje również różnych użytkowników dla tego samego hosta (np. Osobiste konto GitHub i jeden roboczy), który działa w systemie Windows również polega na edycji ~/.ssh/config(lub c:\Users\<your user>\.ssh\config) i określaniu wielu tożsamości:

Host github.com
HostName github.com
IdentityFile /path/to/your/personal/github/private/key
User dandv

Host github-work
HostName github.com
IdentityFile /path/to/your/work/github/private/key
User workuser

Następnie, aby sklonować projekt jako osobisty użytkownik, po prostu uruchom zwykłe git clonepolecenie.

Aby sklonować repozytorium jako workuser, uruchom git clone git@github-work:company/project.git.

Jak stwierdzono tutaj: https://superuser.com/a/912281/607049

Możesz skonfigurować go dla repo:

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

Problem polega na tym, że masz różne zdalne repozytoria na tym samym hoście (powiedzmy github.com) i chcesz z nimi współdziałać przy użyciu różnych kluczy ssh (tj. Różnych kont GitHub).

Aby to zrobić:

1. Najpierw powinieneś zadeklarować różne klucze w ~/.ssh/configpliku.

   # Key for usual repositories on github.com
   Host github.com
   HostName github.com
   User git
   IdentityFile ~/.ssh/id_rsa
   
   # Key for a particular repository on github.com
   Host XXX
   HostName github.com
   User git
   IdentityFile ~/.ssh/id_other_rsa

   W ten sposób kojarzysz drugi klucz z nową przyjazną nazwą „XXX” dla github.com.

2. Następnie musisz zmienić zdalne pochodzenie swojego repozytorium, aby używało zdefiniowanej właśnie przyjaznej nazwy.

   Przejdź do lokalnego folderu repozytorium w wierszu polecenia i wyświetl bieżące zdalne pochodzenie:

   >git remote -v
   origin  git@github.com:myuser/myrepo.git (fetch)
   origin  git@github.com:myuser/myrepo.git (push)

   Następnie zmień pochodzenie za pomocą:

   >git remote set-url origin git@XXX:myuser/myrepo.git
   >git remote -v
   origin  git@XXX:myuser/myrepo.git (fetch)
   origin  git@XXX:myuser/myrepo.git (push)

   Teraz możesz automatycznie naciskać, pobierać ... odpowiednim klawiszem.

GIT_SSH_COMMAND="ssh -i /path/to/git-private-access-key" git clone $git_repo

lub

export GIT_SSH_COMMAND="ssh -i /path/to/git-private-access-key"
git clone REPO
git push

O wiele lepszym pomysłem jest dodanie tego hosta lub adresu IP do .ssh/configpliku w następujący sposób:

Host (a space separated list of made up aliases you want to use for the host)
    User git
    Hostname (ip or hostname of git server)
    PreferredAuthentications publickey
    IdentityFile ~/.ssh/id_rsa_(the key you want for this repo)

Poszedłem ze zmienną środowiskową GIT_SSH. Oto moje opakowanie, podobne do tego z Joe Blocka z góry, ale obsługuje dowolną liczbę argumentów.

Plik ~ / gitwrap.sh

#!/bin/bash
ssh -i ~/.ssh/gitkey_rsa "$@"

Następnie w moim .bashrc dodaj:

export GIT_SSH=~/gitwrap.sh

Jeśli żadne z innych rozwiązań tutaj nie działa, a utworzyłeś wiele kluczy ssh, ale nadal nie możesz robić prostych rzeczy, takich jak

git pull

zakładając, że masz dwa pliki kluczy ssh, takie jak

id_rsa
id_rsa_other_key

następnie w repozytorium git spróbuj:

# Run these commands INSIDE your git directory
eval `ssh-agent -s`
ssh-add ~/.ssh/id_rsa
ssh-add ~/.ssh/id_rsa_other_key

a także upewnij się, że domyślna nazwa użytkownika i identyfikator użytkownika github są poprawne przez:

# Run these commands INSIDE your git directory
git config user.name "Mona Lisa"
git config user.email "mona.lisa@email.com"

Aby uzyskać więcej informacji, zobacz https://gist.github.com/jexchan/2351996

Kiedy musisz połączyć się z github przy pomocy zwykłego żądania ( git pull origin master), ustawienie Hosta jako *w ~/.ssh/configmnie zadziałało, żaden inny Host (powiedzmy „github” lub „gb”) nie działał.

Host *
    User git
    Hostname github.com
    PreferredAuthentications publickey
    IdentityFile ~/.ssh/id_rsa_xxx

Wiele z tych rozwiązań wyglądało kusząco. Jednak najbardziej przydatne okazało się ogólne podejście do git-wrapping-script pod następującym linkiem:

Jak określić plik klucza ssh za pomocą gitpolecenia

Chodzi o to, że nie ma gittakich poleceń jak:

git -i ~/.ssh/thatuserkey.pem clone thatuser@myserver.com:/git/repo.git

Rozwiązaniem Alvina jest użycie dobrze zdefiniowanego skryptu bash-wrapper, który wypełnia tę lukę:

git.sh -i ~/.ssh/thatuserkey.pem clone thatuser@myserver.com:/git/repo.git

Gdzie git.shjest:

#!/bin/bash

# The MIT License (MIT)
# Copyright (c) 2013 Alvin Abad
# https://alvinabad.wordpress.com/2013/03/23/how-to-specify-an-ssh-key-file-with-the-git-command

if [ $# -eq 0 ]; then
    echo "Git wrapper script that can specify an ssh-key file
Usage:
    git.sh -i ssh-key-file git-command
    "
    exit 1
fi

# remove temporary file on exit
trap 'rm -f /tmp/.git_ssh.$$' 0

if [ "$1" = "-i" ]; then
    SSH_KEY=$2; shift; shift
    echo "ssh -i $SSH_KEY \$@" > /tmp/.git_ssh.$$
    chmod +x /tmp/.git_ssh.$$
    export GIT_SSH=/tmp/.git_ssh.$$
fi

# in case the git command is repeated
[ "$1" = "git" ] && shift

# Run the git command
git "$@"

Mogę sprawdzić, czy to rozwiązało problem miałem z mającą użytkownika / klucza uznania dla zdalnej bitbucket z repo git remote update, git pulloraz git clone; wszystkie z nich działają teraz dobrze w cronskrypcie zadania, który w innym przypadku miałby problemy z nawigacją po ograniczonej powłoce. Mogłem również wywołać ten skrypt z poziomu R i nadal rozwiązać dokładnie ten sam cronproblem z uruchomieniem (np system("bash git.sh -i ~/.ssh/thatuserkey.pem pull").).

Nie to, że R jest taki sam jak Ruby, ale jeśli R może to zrobić ... O :-)

jeśli masz na swojej ścieżce katalog, w którym chcesz podpisać się danym plikiem identyfikacyjnym, możesz określić, aby użyć określonego pliku identyfikacyjnego za pomocą pliku .ssh / config, ustawiając ControlPathnp .:

host github.com
  ControlPath ~/Projects/work/**
  HostName github.com
  IdentityFile ~/.ssh/id_work
  User git

Następnie sshużyje określonego pliku tożsamości podczas wykonywania poleceń git w ramach podanej ścieżki roboczej.

Musisz utworzyć ~ / .ssh / config jak poniżej

Host <Your bitbucket server>
User <userid>
Hostname <Your bitbucket server as above>
IdentitiesOnly yes
IdentityFile ~/.ssh/id_rsa<file> This is your private key file

pozwolenie jak poniżej

-rw------- $HOME/.ssh/config

Dodaj swój klucz publiczny do swojego gita (cat ~ / .ssh / id_rsa_pub [lub nazwa simillar])

a następnie klon git jak poniżej

git clone ssh://blahblah@blah.com/userid/test.git

Wiele dobrych odpowiedzi, ale niektóre z nich zakładają wcześniejszą wiedzę administracyjną.

Myślę, że ważne jest, aby wyraźnie podkreślić, że jeśli rozpoczął swój projekt poprzez klonowanie URL internetowej - https://github.com/<user-name>/<project-name>.git
to trzeba się upewnić, że url wartość mocy [remote "origin"]w .git/config zmieniono na SSH URL (patrz blok kodu poniżej).

Oprócz tego upewnij się, że dodajesz sshCommmandnastępujące elementy:

user@workstation:~/workspace/project-name/.git$ cat config
[core]
    repositoryformatversion = 0
    filemode = true
    bare = false
    logallrefupdates = true
    sshCommand = ssh -i ~/location-of/.ssh/private_key -F /dev/null <--Check that this command exist
[remote "origin"]
    url = git@github.com:<user-name>/<project-name>.git  <-- Make sure its the SSH URL and not the WEB URL
    fetch = +refs/heads/*:refs/remotes/origin/*
[branch "master"]
    remote = origin
    merge = refs/heads/master

Przeczytaj więcej na ten temat tutaj .

W systemie Windows z Git Bash możesz dodać następujące repozytorium, ssh-agent bash -c 'ssh-add "key-address"; git remote add origin "rep-address"' na przykład: ssh-agent bash -c 'ssh-add /d/test/PrivateKey.ppk; git remote add origin git@git.test.com:test/test.git'Który klucz prywatny znajduje się na dysku D, test folderu komputera. Również jeśli chcesz sklonować repozytorium, możesz to zmienić za git remote add originpomocągit clone .

Po wprowadzeniu tego do Git Bash, poprosi Cię o hasło!

Uważaj, że klucz prywatny openssh i klucz prywatny kit są różne!

Jeśli utworzyłeś klucze w puttygen, musisz przekonwertować swój klucz prywatny na openssh!

Możesz użyć zmiennej środowiskowej GIT_SSH. Ale będziesz musiał zawinąć ssh i opcje w skrypt powłoki.

Zobacz instrukcję git: man gitw powłoce poleceń.

Używam zshi różne klucze są ładowane automatycznie do mojej powłoki Zsh ssh-agentautomatycznie w innych celach (np. Dostęp do zdalnych serwerów) na moim laptopie. Zmodyfikowałem odpowiedź @ Nicka i używam jej do jednego z moich repozytoriów, które należy często odświeżać. (W tym przypadku to moja, dotfilesktórej chcę ta sama i najnowsza wersja na wszystkich moich komputerach, gdziekolwiek pracuję).

bash -c 'eval `ssh-agent`; ssh-add /home/myname/.dotfiles/gitread; ssh-add -L; cd /home/myname/.dotfiles && git pull; kill $SSH_AGENT_PID'

• Odrodzić agenta ssh
• Dodaj klucz tylko do odczytu do agenta
• Zmień katalog na moje repozytorium git
• Jeśli cdkatalog repo się powiódł, ściągnij ze zdalnego repo
• Zabij spawn ssh-agent. (Nie chciałbym, aby wielu agentów pozostało w pobliżu).

dla gitlaba RSAAuthentication yes

Host gitlab.com
  RSAAuthentication yes
  IdentityFile ~/.ssh/your_private_key_name
  IdentitiesOnly yes

doc jest tutaj

Aby zmienna środowiskowa GIT_SSH_COMMAND działała w systemie Windows zamiast:

set GIT_SSH_COMMAND="ssh -i private_key_file"

Posługiwać się:

set "GIT_SSH_COMMAND=ssh -i private_key_file"

Cytat musi być jak

set "variable=value" 

Niektóre backgorund: https://stackoverflow.com/a/34402887/10671021

Jeśli numer portu SSH nie jest 22 (domyślnie), dodać Port xxw~/.ssh/config

W moim przypadku (synologia)

Host my_synology
    Hostname xxxx.synology.me
    IdentityFile ~/.ssh/id_rsa_xxxx
    User myname
    Port xx

Następnie sklonuj za pomocą tytułu hosta w konfiguracji. („moja_synologia”., aby uniknąć @chopstik '* ”)

git clone my_synology:path/to/repo.git

Jeśli jesteś podobny do mnie, możesz:

• Trzymaj klucze ssh w porządku

• Utrzymuj proste polecenia klonowania git

• Obsługa dowolnej liczby kluczy dla dowolnej liczby repozytoriów.

• Ogranicz obsługę klucza SSH.

Trzymam klucze w ~/.ssh/keyskatalogu.

Wolę konwencję niż konfigurację.

Myślę, że kodeks jest prawem; im jest to prostsze, tym lepiej.

KROK 1 - Utwórz alias

Dodaj ten alias do swojej powłoki: alias git-clone='GIT_SSH=ssh_wrapper git clone'

KROK 2 - Utwórz skrypt

Dodaj ten skrypt ssh_wrapper do ŚCIEŻKI:

#!/bin/bash
# Filename: ssh_wrapper

if [ -z ${SSH_KEY} ]; then
    SSH_KEY='github.com/l3x'  # <= Default key
fi
SSH_KEY="~/.ssh/keys/${SSH_KEY}/id_rsa"
ssh -i "${SSH_KEY}" "$@"

PRZYKŁADY

Użyj klucza github.com/l3x:

KEY=github.com/l3x git-clone https://github.com/l3x/learn-fp-go

W poniższym przykładzie użyto również klucza github.com/l3x (domyślnie):

git-clone https://github.com/l3x/learn-fp-go

Użyj klucza bitbucket.org/lsheehan:

KEY=bitbucket.org/lsheehan git-clone git@bitbucket.org:dave_andersen/exchange.git

UWAGI

Zmień domyślny klucz SSH_KEY w skrypcie ssh_wrapper na używany przez większość czasu. W ten sposób nie musisz przez większość czasu używać zmiennej KEY.

Możesz pomyśleć: „Hej! To się często dzieje z aliasem, skryptem i katalogiem kluczy”, ale dla mnie to konwencja. Prawie wszystkie moje stacje robocze (i serwery w tym zakresie) są skonfigurowane podobnie.

Moim celem jest uproszczenie poleceń, które wykonuję regularnie.

Moje konwencje, np. Skrypty Bash, aliasy itp., Tworzą spójne środowisko i pomagają mi uprościć sprawę.

KISS i imiona mają znaczenie.

Więcej wskazówek dotyczących projektowania znajduje się w rozdziale 4 SOLID Design in Go z mojej książki: https://www.amazon.com/Learning-Functional-Programming-Lex-Sheehan-ebook/dp/B0725B8MYW

Mam nadzieję, że to pomaga. - Lex

Możesz wypróbować pakiet sshmulti npm do obsługi wielu kluczy ssh.

Problem z tą metodą polega na tym, że przynajmniej przy uruchomieniu przez bash.exe w systemie Windows, za każdym razem utworzy nowy proces, który pozostanie uśpiony.

ssh-agent bash -c 'ssh-add /somewhere/yourkey; git clone git@github.com:user/project.git'

Jeśli chcesz użyć tego do repozytorium synchronizacji zgodnie z harmonogramem, musisz dodać „&& ssh-agent -k” na końcu.

Coś jak:

ssh-agent bash -c 'ssh-add C:/Users/user/.ssh/your_key; git -C "C:\Path\to\your\repo" pull && ssh-agent -k' 

ssh-agent -k zabije proces, gdy zostanie on zakończony.

Musiałem tylko dodać klucz, a następnie ponownie uruchomić klon git.

ssh-add ~/.ssh/id_rsa_mynewkey
git clone git@bitbucket.org:mycompany/myrepo.git

Oto włamanie do klucza ssh, które znalazłem, znajdując rozwiązanie tego problemu:

Na przykład masz 2 różne zestawy kluczy:

key1, key1.pub, key2, key2.pub

Trzymaj te klucze w swoim .sshkatalogu

Teraz w swoim .bashrclub .bash_profilealias pliku dodaj następujące polecenia

alias key1='cp ~/.ssh/key1 id_rsa && cp ~/.ssh/key1.pub id_rsa.pub'

alias key2='cp ~/.ssh/key2 id_rsa && cp ~/.ssh/key2.pub id_rsa.pub'

Voila! Masz skrót do przełączania klawiszy w dowolnym momencie!

Mam nadzieję, że to Ci odpowiada.