ssha la -ipossibilité d'indiquer le fichier de clé privée à utiliser lors de l'authentification:

-i identity_file

Sélectionne un fichier dans lequel l'identité (clé privée) pour l'authentification RSA ou DSA est lue. La valeur par défaut est ~/.ssh/identitypour la version de protocole 1 ~/.ssh/id_rsaet ~/.ssh/id_dsapour la version de protocole 2. Les fichiers d'identité peuvent également être spécifiés hôte par hôte dans le fichier de configuration. Il est possible d'avoir plusieurs -ioptions (et plusieurs identités spécifiées dans les fichiers de configuration).

Existe-t-il une méthode similaire pour déterminer gitle fichier de clé privée à utiliser sur un système comportant plusieurs clés privées dans le ~/.sshrépertoire?

Dans ~/.ssh/config, ajoutez:

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

Maintenant vous pouvez faire git clone git@github.com:username/repo.git.

REMARQUE: Vérifiez que les autorisations sur IdentityFile sont 400. SSH rejettera, de manière non explicite, les clés SSH trop lisibles. Cela ressemblera simplement à un rejet de titres de compétences. La solution, dans ce cas, est la suivante:

chmod 400 ~/.ssh/id_rsa_github

Variable d'environnement GIT_SSH_COMMAND:

A partir de la version 2.3.0 de Git, vous pouvez utiliser la variable d'environnement GIT_SSH_COMMANDcomme ceci:

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

Notez que -ivotre fichier de configuration peut parfois remplacer le fichier. Dans ce cas, vous devez donner à SSH un fichier de configuration vide, comme ceci:

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

Configuration core.sshCommand:

À partir de la version 2.10.0 de Git, vous pouvez le configurer par référentiel ou globalement, de sorte que vous n’ayez plus à définir la variable d’environnement!

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

Il n’existe aucun moyen direct de déterminer gitla clé privée à utiliser, car elle dépend sshde l’authentification du référentiel. Cependant, il existe encore quelques moyens pour atteindre votre objectif:

Option 1: ssh-agent

Vous pouvez utiliser ssh-agentpour autoriser temporairement votre clé privée.

Par exemple:

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

Option 2: GIT_SSH_COMMAND

Passez les arguments ssh en utilisant la GIT_SSH_COMMANDvariable d'environnement (Git 2.3.0+).

Par exemple:

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

_{Vous pouvez taper tout cela sur une seule ligne - ignorer $et laisser de côté \.}

Option 3: GIT_SSH

Passez les arguments ssh en utilisant la GIT_SSHvariable d'environnement pour spécifier un autre sshbinaire.

Par exemple:

$ 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

_{Remarque: Les lignes ci-dessus sont des lignes de commande shell (terminal) que vous devez coller dans votre terminal. Ils vont créer un fichier nommé ssh, le rendre exécutable et (indirectement) l'exécuter.}

^{Remarque: GIT_SSHdisponible depuis v0.99.4 (2005).}

Option 4: ~/.ssh/config

Utilisez le ~/.ssh/configfichier comme suggéré dans d'autres réponses afin de spécifier l'emplacement de votre clé privée, par exemple

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

Ecrivez un script qui appelle sshavec les arguments de votre choix et mettez le nom de fichier du script dans $GIT_SSH. Ou mettez simplement votre configuration dans ~/.ssh/config.

Si vous ne souhaitez pas spécifier les variables d'environnement à chaque fois que vous exécutez git, ne voulez pas un autre script wrapper, n'exécutez / ne pouvez pas exécuter ssh-agent (1), et ne souhaitez pas télécharger un autre package rien que pour cela, utilisez git - transport externe à distance (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)

Je considère cette solution supérieure parce que:

• C'est spécifique au dépôt / à distance
• Eviter le gonflement des scripts
• Vous n'avez pas besoin de l'agent SSH - utile si vous voulez des clones / push / pulls sans surveillance (par exemple dans cron)
• Certainement, aucun outil externe nécessaire

Utilisez la configuration d’hôte personnalisée dans ~/.ssh/config, comme ceci:

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

utilisez ensuite votre nom d’hôte personnalisé comme ceci:

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

Après ma lutte avec $GIT_SSHje voudrais partager ce qui a fonctionné pour moi.

À travers mes exemples, je suppose que votre clé privée est située à l'adresse/home/user/.ssh/jenkins

Erreur à éviter: la valeur GIT_SSH inclut des options

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

ou quelque chose de semblable échouera, car git essaiera d'exécuter la valeur sous forme de fichier . Pour cette raison, vous devez créer un script.

Exemple de travail du script $ GIT_SSH /home/user/gssh.sh

Le script sera appelé comme suit:

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

Exemple de script pouvant ressembler à:

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

Notez le $*à la fin, c'est une partie importante de celui-ci.

Une alternative encore plus sûre, qui éviterait tout conflit possible avec quoi que ce soit dans votre fichier de configuration par défaut (en mentionnant explicitement le port à utiliser) serait:

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

En supposant que le script est en place /home/user/gssh.sh, vous devrez alors:

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

et tout fonctionnera.

Vous pouvez simplement utiliser ssh-ident au lieu de créer votre propre wrapper.

Vous pouvez en savoir plus sur: https://github.com/ccontavalli/ssh-ident

Il charge les clés ssh à la demande lorsque cela est nécessaire pour la première fois, même avec plusieurs sessions de connexion, xterms ou foyers partagés NFS.

Avec un fichier de configuration minuscule, il peut charger automatiquement différentes clés et les garder séparées dans différents agents (pour le transfert d'agent) en fonction de vos tâches.

J'ai eu un client qui avait besoin d'un compte séparé github. Je devais donc utiliser une clé distincte uniquement pour ce projet.

Ma solution a été d'ajouter ceci à mon .zshrc / .bashrc:

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

Chaque fois que je veux utiliser git pour ce projet, je remplace "infogit" par git:

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

Pour moi, c'est plus facile à retenir.

Je règle donc la variable env GIT_SSH sur $HOME/bin/git-ssh.

Pour que ma configuration de référentiel dicte l'identité ssh à utiliser, mon ~/bin/git-sshfichier est le suivant:

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

Ensuite, j'ai un paramètre global de configuration git:

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

Et dans n'importe quel référentiel git, je peux simplement définir une ssh.identityvaleur de configuration git locale :

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

Voila!

Si vous pouvez avoir une adresse e-mail différente pour chaque identité, cela devient encore plus simple, car vous pouvez simplement nommer vos clés après vos adresses e-mail, puis laisser le fichier user.email de git config définir la clé de la manière ~/bin/git-sshsuivante:

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

Ma solution était la suivante:

créer un 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

alors quand vous devez changer le var run:

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

N'oubliez pas le point supplémentaire !! cela rend le script définir les environnements vars !! --key et --port sont optionnels.

Généralement, vous voulez utiliser ~/.ssh/configpour cela. Associez simplement les adresses de serveur aux clés que vous souhaitez utiliser pour elles comme suit:

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

Host *dénote tout serveur, donc je l'utilise pour définir ~/.ssh/id_rsacomme clé par défaut à utiliser.

Je construis sur @shellholic et ce fil SO avec quelques tecks. J'utilise GitHub comme exemple et suppose que vous avez une clé privée ~/.ssh/github(sinon, consultez ce fil de discussion SO ) et que vous avez ajouté la clé publique à votre profil GitHub (sinon consultez l'aide de GitHub ).

Si nécessaire, créez un nouveau fichier de configuration SSH à ~/.ssh/configet modifiez les autorisations sur 400

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

Ajoutez ceci au ~/.ssh/configfichier:

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

Si vous avez déjà une configuration à distance, vous pouvez vouloir la supprimer, sinon vous pouvez toujours être invité à entrer votre nom d'utilisateur et votre mot de passe:

git remote rm origin

Ajoutez ensuite une télécommande au référentiel git et notez les deux points avant le nom d'utilisateur:

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

Et ensuite, les commandes git fonctionnent normalement, par exemple:

git push origin master
git pull origin 

@ HeyWatchThis sur ce fil SO a suggéré d'ajouter IdentitiesOnly yespour empêcher le comportement par défaut de SSH d'envoyer le fichier d'identité correspondant au nom de fichier par défaut pour chaque protocole. Voir ce fil pour plus d'informations et de références.

Il suffit d'utiliser ssh-agentet de ssh-addcommandes.

# create an agent
ssh-agent

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

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

Après avoir exécuté les commandes ci-dessus, vous pouvez utiliser les deux touches simultanément. Il suffit de taper

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

pour cloner votre référentiel.

Vous devez exécuter la commande ci-dessus après le redémarrage de votre ordinateur.

J'utilise la version 2.16 de git et je n'ai pas besoin d'un seul script, pas même d'une configuration ou de commandes modifiées.

• Vient de copier ma clé privée dans .ssh / id_rsa
• définir les autorisations à 600

Et git lit à clé automatiquement. Je ne demande rien et ça ne jette pas d'erreur. Ça fonctionne très bien.

Bien que la question ne le demande pas, j'inclus cette réponse pour toute autre personne cherchant à résoudre le même problème spécifiquement pour gitlab .

La solution gitlab

J'ai essayé d'utiliser l' approche des variables d'environnement , mais même la documentation de git recommande de l'utiliser ~/.ssh/configpour autre chose que le cas simple. Dans mon cas, je pousse sur un serveur gitlab - et je voulais le faire en tant qu'utilisateur spécifique - qui est bien sûr défini par la clé privée lors de l' authentification et non par le nom d'utilisateur git. Une fois implémenté, je réalise simplement ce qui suit:

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

Installer

Rappelez-vous l'emplacement de votre clé privée /myfolder/.ssh/my_gitlab_id_rsa dans mon cas.

Ajouter une entrée dans ~/.ssh/config:

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

Ajoutez le git-alias dans ~/.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"

En bonus, j'effectue mes commits sur ce même hôte en tant qu'utilisateur spécifique avec ce git-alias :

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

Explication

Tout ce qui précède suppose que la télécommande appropriée est originet que la branche pertinente est actuellement extraite. Pour référence, j'ai rencontré plusieurs points qui devaient être abordés:

• La solution nécessite la création d'une nouvelle télécommande gitlab_as_meet je n'aimais pas voir la télécommande supplémentaire traîner dans mon arbre de journalisation, alors je la supprime une fois l'opération terminée.
• Afin de créer la télécommande, il est nécessaire de générer l’URL de la télécommande à la volée - dans le cas de gitlab, cela a été réalisé avec une simple coupure bash
• Lorsque vous effectuez un push sur, gitlab_as_mevous devez spécifier la branche sur laquelle vous poussez.
• Après avoir effectué le push, votre originpointeur local doit être "mis à jour" pour correspondre gitlab_as_me(le git pull origin $branchfait ceci)

Lorsque vous avez plusieurs comptes git et que vous voulez une clé ssh différente

Vous devez suivre la même procédure pour générer la clé ssh, mais assurez-vous de

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

Entrez le chemin que vous souhaitez enregistrer (ex: my-pc / Desktop / .ssh / ed25519)

Ajoutez la clé publique à votre gitlab ( Comment ajouter une clé ssh à gitlab )

Vous devez créer une nouvelle identité SSH en utilisant la commande ci-dessous

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