Specifica una chiave SSH per git push per un determinato dominio

Ho il seguente caso d'uso: vorrei poter spingere per git@git.company.com:gitolite-adminusare la chiave privata dell'utente gitolite-admin, mentre voglio spingere per git@git.company.com:some_repousare la 'mia' chiave privata. AFAIK, non posso risolverlo usando ~/.ssh/config, perché il nome utente e il nome del server sono identici in entrambi i casi. Poiché utilizzo principalmente la mia chiave privata, ho definito in ~/.ssh/configper git@git.company.com. Qualcuno conosce un modo per sovrascrivere la chiave utilizzata per una singola gitchiamata?

(A parte: gitolite distingue chi sta facendo il push in base alla chiave, quindi non è un problema, in termini di accesso, proprietà e controllo, che la stringa user @ server sia identica per diversi utenti.)

Anche se l'utente e l'host sono uguali, è comunque possibile distinguerli ~/.ssh/config. Ad esempio, se la configurazione è simile alla seguente:

Host gitolite-as-alice
  HostName git.company.com
  User git
  IdentityFile /home/whoever/.ssh/id_rsa.alice
  IdentitiesOnly yes

Host gitolite-as-bob
  HostName git.company.com
  User git
  IdentityFile /home/whoever/.ssh/id_dsa.bob
  IdentitiesOnly yes

Quindi basta usare gitolite-as-alicee gitolite-as-bobinvece del nome host nel tuo URL:

git remote add alice git@gitolite-as-alice:whatever.git
git remote add bob git@gitolite-as-bob:whatever.git

Nota

Si desidera includere l'opzione IdentitiesOnly yesper impedire l'uso di ID predefiniti. Altrimenti, se hai anche file ID corrispondenti ai nomi predefiniti, verranno prima provati perché a differenza di altre opzioni di configurazione (che rispettano "first in wins") l' IdentityFileopzione si aggiunge all'elenco di identità da provare. Vedi: /server/450796/how-could-i-stop-ssh-offering-a-wrong-key/450807#450807

Un approccio alternativo a quello offerto sopra da Mark Longair è l'uso di un alias che eseguirà qualsiasi comando git, su qualsiasi telecomando, con una chiave SSH alternativa. L'idea è fondamentalmente di cambiare l'identità SSH quando si eseguono i comandi git.

Vantaggi relativi all'approccio alias host nell'altra risposta:

• Funzionerà con qualsiasi comando o alias git, anche se non è possibile specificare remoteesplicitamente.
• Lavorare più facilmente con molti repository perché è necessario configurarlo solo una volta per computer client, non una volta per repository su ciascun computer client.

Uso alcuni piccoli script e un alias git admin. In questo modo posso fare, ad esempio:

git admin push 

Per passare al telecomando predefinito utilizzando la chiave SSH alternativa ("admin"). Ancora una volta, è possibile utilizzare qualsiasi comando (non solo push) con questo alias. Potresti anche fare git admin clone ...per clonare un repository a cui avresti accesso solo usando la tua chiave "admin".

Passaggio 1: crea le chiavi SSH alternative, facoltativamente imposta una passphrase nel caso in cui lo stai facendo sulla macchina di qualcun altro.

Passaggio 2: creare uno script chiamato "ssh-as.sh" che esegue elementi che utilizzano SSH, ma utilizza una determinata chiave SSH anziché quella predefinita:

#!/bin/bash
exec ssh ${SSH_KEYFILE+-i "$SSH_KEYFILE"} "$@"

Passaggio 3: creare uno script chiamato "git-as.sh" che esegue i comandi git utilizzando la chiave SSH fornita.

#!/bin/bash
SSH_KEYFILE=$1 GIT_SSH=${BASH_SOURCE%/*}/ssh-as.sh exec git "${@:2}"

Passaggio 4: aggiungi un alias (utilizzando qualcosa di appropriato per "PATH_TO_SCRIPTS_DIR" di seguito):

# Run git commands as the SSH identity provided by the keyfile ~/.ssh/admin
git config --global alias.admin \!"PATH_TO_SCRIPTS_DIR/git-as.sh ~/.ssh/admin"

Maggiori dettagli su: http://noamlewis.wordpress.com/2013/01/24/git-admin-an-alias-for-running-git-commands-as-a-privileged-ssh-identity/

È possibile utilizzare la variabile di ambiente git GIT_SSH_COMMAND. Esegui questo nel tuo terminale sotto il tuo repository git:

GIT_SSH_COMMAND='ssh -i ~/.ssh/your_private_key' git submodule update --init

Sostituisci ~/.ssh/your_private_keycon il percorso della chiave privata ssh che vuoi usare. E si può cambiare il successivo comando git (nell'esempio è git submodule update --init) ad altri come git pull, git fetchecc

Un sistema basato su Unix (Linux, BSD, Mac OS X), l'identità predefinita è memorizzata nella directory $ HOME / .ssh , in 2 file: private key: $HOME/.ssh/id_rsa public key: $HOME/.ssh/id_rsa.pub quando si utilizza sshsenza opzione -i, utilizza la chiave privata predefinita per l'autenticazione con il sistema remoto.

Se si dispone di un'altra chiave privata che si desidera utilizzare, ad esempio $ HOME / .ssh / deploy_key , è necessario utilizzaressh -i ~/.ssh/deploy_key ...

È noioso. Puoi aggiungere le seguenti righe al tuo $ HOME / .bash_profile : ssh-add ~/.ssh/deploy_key ssh-add ~/.ssh/id_rsa

Quindi ogni volta che usi ssho gito scp(sostanzialmente sshanche), non devi più usare l'opzione -i.

Puoi aggiungere tutte le chiavi che vuoi nel file $ HOME / .bash_profile .

Un'altra alternativa è usare ssh-ident, per gestire le tue identità ssh .

Carica automaticamente e utilizza chiavi diverse in base alla directory di lavoro corrente, alle opzioni ssh e così via ... il che significa che puoi avere facilmente una directory di lavoro / e privata / che finisce con l'uso di chiavi e identità diverse con ssh.

Sto usando Git Bash su Win7. Quanto segue ha funzionato per me.

Crea un file di configurazione in ~ / .ssh / config oppure c: / users / [nome_utente] /. Ssh / config. Nel file inserisci:

Host your_host.com
     IdentityFile [absolute_path_to_your_.ssh]\id_rsa

Immagino che l'host debba essere un URL e non solo un "nome" o un riferimento per il tuo host. Per esempio,

Host github.com
     IdentityFile c:/users/[user_name]/.ssh/id_rsa

Il percorso può anche essere scritto nel formato / c / users / [nome_utente] / ....

Ottima anche la soluzione fornita da Giordano Scalzo. https://stackoverflow.com/a/9149518/1738546

Da git 2.10 in poi è anche possibile usare l'impostazione gitconfig sshCommand. Stato dei documenti :

Se questa variabile è impostata, git fetch e git push useranno il comando specificato invece di ssh quando devono connettersi a un sistema remoto. Il comando ha la stessa forma della variabile d'ambiente GIT_SSH_COMMAND e viene sovrascritto quando viene impostata la variabile d'ambiente.

Un esempio di utilizzo sarebbe: git config core.sshCommand "ssh -i ~/.ssh/[insert_your_keyname]

In alcuni casi questo non funziona perché ssh_config ha la precedenza sul comando, in questo caso prova ssh -i ~/.ssh/[insert_your_keyname] -F /dev/nulla non usare ssh_config.

Ho paralizzato e testato con github il seguente approccio, basato sulla lettura di altre risposte, che combina alcune tecniche:

• corretta configurazione SSH
• riscrittura URL git

Il vantaggio di questo approccio è che, una volta impostato, non richiede alcun lavoro aggiuntivo per farlo correttamente - ad esempio, non è necessario modificare gli URL remoti o ricordare di clonare le cose in modo diverso - la riscrittura degli URL fa funzionare tutto .

~/.ssh/config

# Personal GitHub
Host github.com
  HostName github.com
  User git
  AddKeysToAgent yes
  UseKeychain yes
  IdentityFile ~/.ssh/github_id_rsa

# Work GitHub
Host github-work
  HostName github.com
  User git
  AddKeysToAgent yes
  UseKeychain yes
  IdentityFile ~/.ssh/work_github_id_rsa

Host *
  IdentitiesOnly yes

~/.gitconfig

[user]
    name = My Name
    email = personal@personal.email

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

[url "github-work:work-github-org/"]
    insteadOf = git@github.com:work-github-org/

~/dev/work/.gitconfig

[user]
    email = work@work.email

Fintanto che manterrai tutti i repository di lavoro sotto ~ / dev / work e cose personali altrove, git utilizzerà la chiave SSH corretta quando eseguirà pull / cloni / push sul server e collegherà l'indirizzo di posta elettronica corretto a tutti i tuoi impegni.

Riferimenti:

• 1

• 2

Se si utilizza la versione di ssh di Git su Windows, appare la riga del file di identità nella configurazione di ssh

IdentityFile /c/Users/Whoever/.ssh/id_rsa.alice

dove /csta perc:

Per verificare, in bash di Git

cd ~/.ssh
pwd 

Potrebbe essere necessario rimuovere (o commentare) la configurazione host predefinita

più specificato nella chiave di configurazione del file ssh:

# Default GitHub user
Host one
 HostName gitlab.com
 User git
 PreferredAuthentications publickey
 IdentityFile ~/.ssh/key-one
 IdentitiesOnly yes

#two user
Host two
 HostName gitlab.com
 User git
 PreferredAuthentications publickey
 IdentityFile ~/.ssh/key-two
 IdentitiesOnly yes

Come indicato da qualcun altro, core.sshCommandconfig può essere utilizzato per sovrascrivere la chiave SSH e altri parametri.

Ecco un esempio in cui hai una chiave alternativa denominata ~/.ssh/workrsae vuoi usarla per tutti i repository clonati in ~/work.

1. Crea un nuovo .gitconfigfile sotto ~/work:

[core]
  sshCommand = "ssh -i ~/.ssh/workrsa"

2. Nella tua configurazione globale di git ~/.gitconfig, aggiungi:

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

Una possibilità da utilizzare ~/.ssh/configè utilizzare la Matchrestrizione anziché la Hostrestrizione. In particolare Match Execchiama un comando shell per decidere se applicare o meno le dichiarazioni. In bash puoi usare il seguente comando:

[ git@git.company.com:gitolite-admin = $(git config --get remote.origin.url)'' ]

Questo utilizza il [comando bash per verificare se due stringhe sono uguali. In questo caso sta verificando se la stringa git@git.company.com:gitolite-admincorrisponde all'output ottenuto dal $(git config --get remote.origin.url)''comando.

È possibile utilizzare qualsiasi altro comando che identifichi il repository su cui si trova la shell. Perché questo funzioni è importante avere la $SHELLvariabile definita sulla shell, nel mio caso /bin/bash. L'esempio completo sarebbe quindi il seguente ~/.ssh/config:

Match Exec "[ git@git.company.com:gitolite-admin = $(git config --get remote.origin.url)'' ]"
  IdentityFile ~/.ssh/gitolite-admin
  IdentitiesOnly yes
  ForwardAgent no
  ForwardX11 no
  ForwardX11Trusted no

Match Exec "[ git@git.company.com:some_repo = $(git config --get remote.origin.url)'' ]"
  IdentityFile ~/.ssh/yourOwnPrivateKey
  IdentitiesOnly yes
  ForwardAgent no
  ForwardX11 no
  ForwardX11Trusted no

In questo esempio ho assunto che ~/.ssh/yourOwnPrivateKeycontenga la tua chiave privata e che ~/.ssh/gitolite-admincontenga la chiave privata dell'utente gitolite-admin. Ho incluso la IdentitiesOnly yesdichiarazione per assicurarmi che al server git sia offerta una sola chiave, menzionata da Mark Longair . Le altre dichiarazioni sono solo opzioni ssh standard per git.

Puoi aggiungere questa configurazione se ne hai diversi some_repoche vuoi usare con chiavi diverse. Se si dispone di più repository git@git.company.come la maggior parte di essi utilizza la funzione, ~/.ssh/yourOwnPrivateKeyè più sensato includere questa chiave come predefinita per l'host. In questo caso ~/.ssh/configsarebbe:

Match Exec "[ git@git.company.com:gitolite-admin = $(git config --get remote.origin.url)'' ]"
  IdentityFile ~/.ssh/gitolite-admin
  IdentitiesOnly yes

Host git.company.com
  IdentityFile ~/.ssh/yourOwnPrivateKey
  IdentitiesOnly yes
  ForwardAgent no
  ForwardX11 no
  ForwardX11Trusted no

Si noti che l'ordine è importante e la Host git.company.comrestrizione dovrebbe apparire dopo Match Execquella o quelle.

Configura il tuo repository utilizzando git config. Per esempio:

git config --add --local core.sshCommand 'ssh -i ~/.ssh/<<<PATH_TO_SSH_KEY>>>'