In ~/.ssh/config, aggiungere:

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

Se il file di configurazione è nuovo, non dimenticare di fare chmod 600 ~/.ssh/config

Ora puoi fare git clone git@github.com:{ORG_NAME}/{REPO_NAME}.git

• Dove {ORG_NAME} è il tuo account utente GitHub (o account dell'organizzazione) il nome GitHub URI.
• Si noti che c'è un due punti : dopo github.com invece della barra / - poiché questo non è un URI.
• E {REPO_NAME} è il nome URI del vostro repo GitHub
• Per esempio, per il kernel Linux questo sarebbe git clone git@github.com:torvalds/linux.git).

NOTA: Su Linux e macOS, verificare che i permessi sul vostro IdentityFile siano 400. SSH rifiuterà, in modo non chiaramente esplicito, le chiavi SSH troppo leggibili. Sembrerà solo un rifiuto di credenziali. La soluzione, in questo caso, è:

chmod 400 ~/.ssh/id_rsa_github

Variabile d'ambiente GIT_SSH_COMMAND:

Dalla versione 2.3.0 di Git, si può usare la variabile d'ambiente GIT_SSH_COMMAND così:

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

Si noti che -i a volte può essere sovrascritto dal file di configurazione, nel qual caso si dovrebbe dare a SSH un file di configurazione vuoto, così:

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

Configurazione core.sshCommand:

Dalla versione 2 di Git. 10.0, è possibile configurarlo per repo o globalmente, in modo da non dover più impostare la variabile d'ambiente!

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

Non c'è no direct modo per dire a git quale chiave privata utilizzare, perché si basa su ssh per l'autenticazione del repository. Tuttavia, ci sono ancora alcuni modi per raggiungere il vostro obiettivo:

Opzione 1: ssh-agent

Potete usare ssh-agent per autorizzare temporaneamente la vostra chiave privata.

Per esempio:

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

Opzione 2: GIT_SSH_COMMAND

Passate gli argomenti ssh usando la variabile d'ambiente GIT_SSH_COMMAND (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
``` ```
$ 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

Si può digitare tutto su una sola riga - ignorare $ e tralasciare Non c'è **no _direct_ modo** per dire agitquale chiave privata utilizzare, perché si basa sussh` per l'autenticazione del repository. Tuttavia, ci sono ancora alcuni modi per raggiungere il vostro obiettivo:

Opzione 1: ssh-agent

Potete usare ssh-agent per autorizzare temporaneamente la vostra chiave privata.

Per esempio:

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

Opzione 2: GIT_SSH_COMMAND

Passate gli argomenti ssh usando la variabile d'ambiente GIT_SSH_COMMAND (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
``` ```
$ 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

Si può digitare tutto su una sola riga - ignorare $ e tralasciare .

Opzione 3: GIT_SSH

Passare gli argomenti ssh usando la variabile d'ambiente GIT_SSH per specificare il binario alternativo ssh.

Per esempio:

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

Nota: Le righe di cui sopra sono linee di comando shell (terminale) che si devono incollare nel terminale. Esse 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 file ~/.ssh/config come suggerito in altre risposte per specificare la posizione della vostra chiave privata, ad esempio

&001

Scrivete uno script che chiami ssh con gli argomenti che volete, e mettete il nome del file dello script in $GIT_SSH. Oppure mettete la vostra configurazione in ~/.ssh/config.

Utilizzare la configurazione host personalizzata in ~/.ssh/config, come questa:

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

quindi utilizzare il nome host personalizzato come questa:

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

Se non volete dover specificare variabili d'ambiente ogni volta che eseguite git, non volete un altro script wrapper, non/non potete eseguire ssh-agent(1), né volete scaricare un altro pacchetto solo per questo, usate il trasporto esterno git-remote-ext(1):

$ 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 per il repository/remote
• Evita il gonfiore dello script wrapper
• Non serve l'agente SSH – utile se si vogliono cloni/push/pull non presidiati (e. g. in cron)
• Sicuramente non è necessario uno strumento esterno

Dopo la mia lotta con $GIT_SSH vorrei condividere ciò che ha funzionato per me.

Attraverso i miei esempi suppongo che la vostra chiave privata si trovi a/home/user/.ssh/jenkins

Errore da evitare: Il valore GIT_SSH include le opzioni

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

o qualsiasi altro valore simile fallisce, poiché git cercherà di eseguire il valore come file. Per questo motivo, è necessario creare uno script.

Esempio di lavoro di $GIT_SSH script /home/user/gssh.sh

Lo script sarà invocato come segue:

$ $GIT_SSH [username@]host [-p <port>] <command>
``` ```
#!/bin/sh
ssh -i /home/user/.ssh/jenkins $*

Esempio di script funzionante potrebbe assomigliare a:

#!/bin/sh
ssh -i /home/user/.ssh/jenkins -F /dev/null -p 22 $*
``` ```
$ export GIT_SSH=/home/user/gssh.sh

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

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

&001 &001

Supponendo che lo script sia in /home/user/gssh.sh, allora:

&001 &001

e tutto funzionerà.

Potete usare ssh-ident invece di creare il vostro involucro.

Potete saperne di più all'indirizzo: https://github.com/ccontavalli/ssh-ident &003

Carica le chiavi ssh su richiesta al primo bisogno, una volta, anche con sessioni di login multiple, xterms o case condivise NFS.

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

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

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

alias infogit="GIT_SSH_COMMAND=\"ssh -i ~/.ssh/id_specialkey\" git $@"
``` ```
infogit commit -am "Some message" && infogit push

Ogni volta che voglio usare git per quel progetto sostituisco “infogit” con git:

&001

Per me è più facile da ricordare.

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

Per supportare il mio repo di configurazione dettargli l'identità ssh da utilizzare, il mio file ~/bin/git-ssh è questo:

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

Allora ho un'impostazione globale di configurazione git:

$ git config --global ssh.identity ~/.ssh/default_id_rsa
``` ```
$ git config --local ssh.identity ~/.ssh/any_other_id_rsa

e all'interno di qualsiasi repository git posso semplicemente impostare un valore di configurazione git locale ssh.identity:

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

Voilà!

Se si può avere un indirizzo email diverso per ogni identità, diventa ancora più semplice, perché si può semplicemente dare un nome alle chiavi con il nome dei propri indirizzi email e poi fare in modo che il git config user.email guidi la selezione delle chiavi in un ~/bin/git-ssh come questo:

&001

Costruisco su @shellholic e questo filo SO con qualche tek. Uso GitHub come esempio e suppongo che tu abbia una chiave privata in ~/.ssh/github (altrimenti, vedi this SO thread ) e che tu abbia aggiunto la chiave pubblica al tuo profilo GitHub (altrimenti vedi GitHub’s help ).

Se necessario, creare un nuovo file di configurazione SSH a ~/.ssh/config e cambiare i permessi a 400

touch ~/.ssh/config
chmod 600 ~/.ssh/config
``` ```
Host github.com
    IdentityFile ~/.ssh/github
    IdentitiesOnly yes

Aggiungi questo al file ~/.ssh/config:

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

Se hai già una configurazione remota, potresti volerla cancellare, altrimenti potrebbero ancora esserti richiesti username e password:

git push origin master
git pull origin
``` &001 


Poi aggiungete un telecomando al repository git, e notate i due punti prima del nome utente: 


&001 &001 


E poi i comandi git funzionano normalmente, e. g.: 


&001 &001 


@HeyWatchThis su [ questo thread SO ](https://stackoverflow.com/questions/4565700/specify-private-ssh-key-to-use-when-executing-shell-command) ha suggerito di aggiungere `IdentitiesOnly yes` per evitare il comportamento predefinito di SSH di inviare il file di identità corrispondente al nome file predefinito per ogni protocollo. Vedere quel thread per maggiori informazioni e riferimenti.

La mia soluzione è stata 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

e poi quando si deve cambiare il var eseguire:

. ./thescript.sh [--port=] [--key=]
``` &001 


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

In generale, si vuole usare ~/.ssh/config per questo. Basta associare gli indirizzi dei 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_rsa come chiave predefinita da utilizzare.

Basta usare i comandi ssh-agent e ssh-add.

# create an agent
ssh-agent

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

# add your second key
ssh-add ~/.ssh/<your key name>
``` ```
git clone git@github.com:<yourname>/<your-repo>.git

Dopo aver eseguito i comandi di cui sopra, si possono usare entrambi i tasti contemporaneamente. Basta digitare

&001 &001

per clonare il vostro repository.

È necessario eseguire il comando di cui sopra dopo aver riavviato la macchina.

# 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

Anche se la domanda non lo richiede, sto includendo questa risposta per chiunque altro cerchi di risolvere lo stesso problema proprio per gitlab .

La soluzione gitlab

Ho provato ad usare l'approccio ambiente-variabile , ma anche la documentazione git raccomanda di usare ~/.ssh/config per qualcosa di più del semplice caso. Nel mio caso sto spingendo verso un server gitlab - e volevo farlo come utente specifico - che è naturalmente definito dalla private-key durante l'autenticazione private-key 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...]

Setup

Richiamo la posizione del vostro private-key /myfolder/.ssh/my_gitlab_id_rsa nel mio caso.

Aggiungo una voce in ~/.ssh/config:

Host gitlab-delegate
    HostName gitlab.mydomain.com
    User git
    IdentityFile /myfolder/.ssh/my_gitlab_id_rsa
    IdentitiesOnly yes
``` ```
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"

Aggiungo il git-alias in ~/.gitconfig:

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


Come bonus, eseguo i miei impegni su questo stesso host come utente specifico ](https://stackoverflow.com/a/19841156/1808261) con questo [ git-alias ](/questions/tagged/git-alias "show questions tagged 'git-alias'"): 


&001 &001 


# Spiegazione 


Tutto quanto sopra presuppone che il relativo telecomando sia `origin` e che il relativo ramo sia attualmente controllato. Per riferimento mi sono imbattuto in diversi elementi che dovevano essere affrontati: 


- La soluzione richiede la creazione di un nuovo telecomando `gitlab_as_me`, e non mi è piaciuto vedere il telecomando extra [ appeso nel mio albero di tronchi ](https://www.merriam-webster.com/dictionary/pun) così lo tolgo quando ho finito 
- Per creare il telecomando, è necessario generare l'url del telecomando al volo - nel caso di gitlab questo è stato ottenuto con un semplice bash [ cut ](/questions/tagged/cut "show questions tagged 'cut'") 
- Quando si esegue un push a `gitlab_as_me` è necessario essere specifici su quale ramo si sta spingendo 
- Dopo aver eseguito il push il puntatore locale `origin` deve essere "aggiornato" in modo da corrispondere a `gitlab_as_me` (il `git pull origin $branch` fa questo)

Quando avete un account git multiplo e volete una diversa chiave ssh

Dovete seguire lo stesso passo per generare la chiave ssh, ma assicuratevi di

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

Inserite il percorso che volete salvare(Es: my-pc/Desktop/. ssh/ed25519)

Aggiungete la chiave pubblica al vostro gitlab Come aggiungere la chiave ssh a gitlab )

Dovete aggiungere la nuova identità ssh usando il seguente comando

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

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

• Ho appena copiato la mia chiave privata in .ssh/id_rsa
• imposta i permessi a 600

e git legge automaticamente sulla chiave. Non chiedo nulla e non lancia un errore. Funziona bene.

Se avete bisogno di collegarvi allo stesso host con chiavi diverse, potete farlo tramite:

1. 1. Configurare l’~/.ssh/config con diversi host ma con gli stessi HostNames.
2. 3. Clonare il vostro repo utilizzando l'host appropriato.

Esempio:

~/.ssh/config

Host work
 HostName bitbucket.org
 IdentityFile ~/.ssh/id_rsa_work
 User git

Host personal
 HostName bitbucket.org
 IdentityFile ~/.ssh/id_rsa_personal
 User git

Poi invece clonare il vostro repo come:

git clone git@bitbucket.org:username/my-work-project.git
git clone git@bitbucket.org:username/my-personal-project.git

dovete fare

git clone git@work:username/my-work-project.git
git clone git@personal:username/my-personal-project.git