sshha la -ipossibilità di dire quale file di chiave privata utilizzare durante l'autenticazione:

-i identity_file

Seleziona un file da cui viene letta l'identità (chiave privata) per l'autenticazione RSA o DSA. L'impostazione predefinita è ~/.ssh/identityper il protocollo versione 1 ~/.ssh/id_rsae ~/.ssh/id_dsaper il protocollo versione 2. I file di identità possono anche essere specificati su base per host nel file di configurazione. È possibile avere più -iopzioni (e più identità specificate nei file di configurazione).

Esiste un modo simile per dire gitquale file di chiave privata utilizzare su un sistema con più chiavi private nella ~/.sshdirectory?

In ~/.ssh/config, aggiungi:

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

Adesso puoi farlo git clone git@github.com:username/repo.git.

NOTA: verificare che le autorizzazioni su IdentityFile siano 400. SSH rifiuterà, in modo non chiaramente esplicito, chiavi SSH troppo leggibili. Sembrerà solo un rifiuto delle credenziali. La soluzione, in questo caso, è:

chmod 400 ~/.ssh/id_rsa_github

Variabile d'ambiente GIT_SSH_COMMAND:

Da Git versione 2.3.0, puoi usare la variabile d'ambiente in GIT_SSH_COMMANDquesto modo:

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

Si noti che -ia volte può essere sovrascritto il file di configurazione, in questo caso, si dovrebbe dare SSH un file di configurazione vuoto, in questo modo:

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

Configurazione core.sshCommand:

Dalla versione 2.10.0 di Git, è possibile configurarlo per repository o globalmente, quindi non è più necessario impostare la variabile di ambiente!

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

Non esiste un modo diretto per dire gitquale chiave privata utilizzare, perché si basa sull'autenticazione sshdel repository. Tuttavia, ci sono ancora alcuni modi per raggiungere il tuo obiettivo:

Opzione 1: ssh-agent

È possibile utilizzare ssh-agentper autorizzare temporaneamente la chiave privata.

Per esempio:

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

Opzione 2: GIT_SSH_COMMAND

Passa gli argomenti ssh usando la GIT_SSH_COMMANDvariabile d'ambiente (Git 2.3.0+).

Per esempio:

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

_{Puoi digitare tutto su una riga: ignora $ed escludi il \.}

Opzione 3: GIT_SSH

Passare gli argomenti ssh utilizzando la GIT_SSHvariabile di ambiente per specificare il file sshbinario alternativo .

Per esempio:

$ 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

_{Nota: le righe sopra sono righe di comando shell (terminale) che è necessario incollare nel terminale. Creeranno un file chiamato ssh, lo renderanno eseguibile e (indirettamente) lo eseguiranno.}

^{Nota: GIT_SSHè disponibile dalla v0.99.4 (2005).}

Opzione 4: ~/.ssh/config

Utilizzare il ~/.ssh/configfile come suggerito in altre risposte per specificare la posizione della chiave privata, ad es

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

Scrivi uno script che chiama sshcon gli argomenti desiderati e inserisci il nome file dello script $GIT_SSH. O semplicemente inserisci la tua configurazione ~/.ssh/config.

Se non si desidera specificare variabili di ambiente ogni volta che si esegue git, non si desidera un altro script wrapper, non è possibile / non è possibile eseguire ssh-agent (1), né si desidera scaricare un altro pacchetto solo per questo, utilizzare git -remote-ext (1) trasporto esterno:

$ 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)

Considero questa soluzione superiore perché:

• È specifico del repository / remoto
• Evitare il gonfiore degli script wrapper
• Non è necessario l'agente SSH - utile se si desidera cloni / push / pull incustoditi (ad es. In cron)
• Sicuramente, non è necessario alcuno strumento esterno

Usa la configurazione dell'host personalizzata in ~/.ssh/configquesto modo:

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

quindi usa il tuo nome host personalizzato in questo modo:

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

Dopo la mia lotta, $GIT_SSHvorrei condividere ciò che ha funzionato per me.

Attraverso i miei esempi, suppongo che tu abbia la tua chiave privata in/home/user/.ssh/jenkins

Errore da evitare: il valore GIT_SSH include opzioni

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

o qualunque cosa simile fallirà, poiché git tenterà di eseguire il valore come file . Per questo motivo, devi creare uno script.

Esempio di funzionamento dello script $ GIT_SSH /home/user/gssh.sh

Lo script verrà invocato come segue:

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

Il funzionamento dello script di esempio potrebbe essere simile a:

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

Nota $*alla fine, è una parte importante di esso.

Un'alternativa ancora più sicura, che impedirebbe qualsiasi possibile conflitto con qualsiasi cosa nel tuo file di configurazione predefinito (oltre a menzionare esplicitamente la porta da usare) sarebbe:

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

Supponendo che lo script sia presente /home/user/gssh.sh, dovrai quindi:

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

e tutto dovrebbe funzionare.

Puoi semplicemente usare ssh-ident invece di creare il tuo proprio wrapper.

Puoi leggere di più su: https://github.com/ccontavalli/ssh-ident

Carica chiavi ssh su richiesta quando necessario, una volta, anche con sessioni di accesso multiple, xterm o case condivise NFS.

Con un piccolo file di configurazione, può caricare automaticamente chiavi diverse e tenerle separate in agenti diversi (per l'inoltro dell'agente) a seconda di ciò che è necessario fare.

Avevo un cliente che aveva bisogno di un account github separato. Quindi avevo bisogno di usare una chiave separata solo per questo progetto.

La mia soluzione era quella di aggiungere questo al mio .zshrc / .bashrc:

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

Ogni volta che voglio usare git per quel progetto, sostituisco "infogit" con git:

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

Per me è più facile da ricordare.

Quindi ho impostato la variabile env GIT_SSH su $HOME/bin/git-ssh.

Per supportare la configurazione della mia repository che determina l'identità ssh da utilizzare, il mio ~/bin/git-sshfile è questo:

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

Quindi ho un'impostazione globale di configurazione git:

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

E all'interno di qualsiasi repository git posso semplicemente impostare un ssh.identityvalore di configurazione git locale :

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

Ecco!

Se puoi avere un indirizzo e-mail diverso per ogni identità, diventa ancora più semplice, perché puoi semplicemente nominare le tue chiavi dopo i tuoi indirizzi e-mail e quindi avere user.email di git config che guida la selezione della chiave in ~/bin/git-sshquesto modo:

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

La mia soluzione era questa:

creare uno script:

#!/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

quindi quando devi cambiare la corsa var:

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

Non dimenticare il punto extra !! questo rende lo script impostato variando gli ambienti !! --key e --port sono opzionali.

In generale, si desidera utilizzare ~/.ssh/configper questo. Associare semplicemente gli indirizzi del server con le chiavi che si desidera utilizzare per loro come segue:

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

Host *indica qualsiasi server, quindi lo uso per impostare ~/.ssh/id_rsacome chiave predefinita da utilizzare.

Mi baso su @shellholic e su questo thread SO con alcuni suggerimenti. Uso GitHub come esempio e presumo che tu abbia una chiave privata ~/.ssh/github(altrimenti, vedi questo thread SO ) e che hai aggiunto la chiave pubblica al tuo profilo GitHub (altrimenti vedi la guida di GitHub ).

Se necessario, creare un nuovo file di configurazione SSH su ~/.ssh/confige modificare le autorizzazioni su 400

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

Aggiungi questo al ~/.ssh/configfile:

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

Se hai già una configurazione remota, potresti voler eliminarla, altrimenti ti potrebbero essere richiesti username e password:

git remote rm origin

Quindi aggiungi un telecomando al repository git e nota i due punti prima del nome utente:

git remote add origin git@github.com:user_name/repo_name.git

E poi i comandi git funzionano normalmente, ad esempio:

git push origin master
git pull origin 

@HeyWatchQuesto su questo thread SO ha suggerito di aggiungere IdentitiesOnly yesper impedire al comportamento predefinito SSH di inviare il file di identità corrispondente al nome file predefinito per ciascun protocollo. Vedi quel thread per maggiori informazioni e riferimenti.

Basta usare ssh-agente ssh-addcomandi.

# create an agent
ssh-agent

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

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

Dopo aver eseguito i comandi precedenti, è possibile utilizzare entrambi i tasti contemporaneamente. Basta digitare

git clone git@github.com:<yourname>/<your-repo>.git

per clonare il tuo repository.

È necessario eseguire il comando sopra dopo aver riavviato il computer.

Sto usando git versione 2.16 e non ho bisogno di un singolo pezzo di script nemmeno di una configurazione o comandi modificati.

• Ho appena copiato la mia chiave privata in .ssh / id_rsa
• impostare le autorizzazioni su 600

E git legge automaticamente la chiave. Non chiedo nulla e non genera un errore. Funziona bene.

Sebbene la domanda non lo richieda, includo questa risposta per chiunque cerchi di risolvere lo stesso problema proprio per Gitlab .

La soluzione gitlab

Ho provato ad usare l' approccio delle variabili d'ambiente , ma anche la documentazione di git consiglia di usarla ~/.ssh/configper qualcosa di più del semplice caso. Nel mio caso sto spingendo su un server gitlab - e volevo farlo come un utente specifico - che è ovviamente definito dalla chiave privata durante l' autenticazione e non dal nome utente git. Una volta implementato, eseguo semplicemente quanto segue:

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

Impostare

Richiama la posizione della tua chiave privata /myfolder/.ssh/my_gitlab_id_rsa nel mio caso.

Aggiungi una voce in ~/.ssh/config:

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

Aggiungi il git-alias in ~/.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"

Come bonus, eseguo i miei commit su questo stesso host di un utente specifico con questo git-alias :

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

Spiegazione

Tutto quanto sopra presuppone che il telecomando in questione sia origine che il ramo pertinente sia attualmente estratto. Per riferimento ho incontrato diversi elementi che dovevano essere affrontati:

• La soluzione richiede la creazione di un nuovo telecomando gitlab_as_mee non mi è piaciuto vedere il telecomando aggiuntivo in giro nel mio albero di registro, quindi lo rimuovo al termine
• Per creare il telecomando, è necessario generare l'URL del telecomando al volo - nel caso di gitlab questo è stato ottenuto con un semplice taglio bash
• Quando esegui una spinta verso di gitlab_as_mete devi essere specifico su quale ramo stai spingendo
• Dopo aver eseguito il push, il originpuntatore locale deve essere "aggiornato" per corrispondere gitlab_as_me(lo git pull origin $branchfa)

Quando si dispone di più account Git e si desidera una chiave SSH diversa

Devi seguire lo stesso passo per generare il tasto ssh, ma assicurati di farlo

ssh-keygen -t ed25519 -C "your-email-id@gmail.com" 

Immettere il percorso che si desidera salvare (ad es. My-pc / Desktop / .ssh / ed25519)

Aggiungi la chiave pubblica a gitlab ( Come aggiungere la chiave ssh a gitlab )

Devi creare una nuova identità ssh usando il comando seguente

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 "first.last@corp.com"
    # 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 "me@gmail.com"
    # 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 git@git.in.corp.com: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 <first.last@corp.com>"
    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 git@github.com: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 <first.last@gmail.com>"
    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