Dans ~/.ssh/config, ajoutez :

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

Si le fichier de configuration est nouveau, n'oubliez pas de faire chmod 600 ~/.ssh/config

Maintenant vous pouvez faire git clone git@github.com:{ORG_NAME}/{REPO_NAME}.git

• Où {ORG_NAME} est le nom URI de votre compte d'utilisateur GitHub (ou compte d'organisation).
• Notez qu'il y a deux points : après github.com au lieu d'une barre oblique / - car ce n'est pas un URI.
• Et {REPO_NAME} est le nom URI de votre repo GitHub
• Par exemple, pour le noyau Linux ce serait git clone git@github.com:torvalds/linux.git).

NOTE : Sur Linux et macOS, vérifiez que les permissions sur votre IdentityFile sont de 400. SSH rejettera, de manière non clairement explicite, les clés SSH qui sont trop lisibles. Cela ressemblera simplement à un rejet de justificatif d'identité. La solution, dans ce cas, est :

chmod 400 ~/.ssh/id_rsa_github

Variable d'environnement GIT_SSH_COMMAND :

Depuis la version 2.3.0 de Git, vous pouvez utiliser la variable d'environnement GIT_SSH_COMMAND comme ceci :

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

Notez que -i peut parfois être écrasé par votre fichier de configuration, 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 :

Depuis la version 2 de Git. 10.0, vous pouvez configurer ceci par repo ou globalement, donc vous n'avez plus besoin de 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'y a pas de manière directe de dire à git quelle clé privée utiliser, car il s'appuie sur ssh pour l'authentification du dépôt. Cependant, il existe encore quelques moyens d'atteindre votre objectif :

Option 1 : ssh-agent

Vous pouvez utiliser ssh-agent pour 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 variable d'environnement GIT_SSH_COMMAND (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 - ignorez $ et laissez de côté le Il n'y a pas de **manière directe** de dire àgitquelle clé privée utiliser, car il s'appuie surssh` pour l'authentification du dépôt. Cependant, il existe encore quelques moyens d'atteindre votre objectif :

Option 1 : ssh-agent

Vous pouvez utiliser ssh-agent pour 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 variable d'environnement GIT_SSH_COMMAND (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 - ignorez $ et laissez de côté le .

Option 3 : GIT_SSH

Passez les arguments ssh en utilisant la variable d'environnement GIT_SSH pour spécifier un autre ssh binaire.

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

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

Note : GIT_SSH est disponible depuis v0.99.4 (2005).

Option 4 : ~/.ssh/config

Utilisez le fichier ~/.ssh/config comme suggéré dans les 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

Écrivez un script qui appelle ssh avec les arguments que vous voulez, et mettez le nom de fichier du script dans $GIT_SSH. Ou bien mettez simplement votre configuration dans ~/.ssh/config.

Utilisez la configuration personnalisée de l'hôte dans ~/.ssh/config, comme ceci :

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

puis utilisez votre nom d'hôte personnalisé comme ceci :

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

Si vous ne voulez pas avoir à spécifier des variables d'environnement chaque fois que vous exécutez git, si vous ne voulez pas d'un autre script d'habillage, si vous ne voulez/pouvez pas exécuter ssh-agent(1), ou si vous voulez télécharger un autre paquet juste pour cela, utilisez le transport externe 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)

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

• Elle est spécifique au dépôt/à la distance
• Elle évite le gonflement du script de wrapper
• Elle ne nécessite pas l'agent SSH – utile si vous voulez des clones/push/pulls sans surveillance (e. (par exemple dans cron)
• Aucun outil externe n'est nécessaire

Après mon combat avec $GIT_SSH, je voudrais partager ce qui a fonctionné pour moi.

A travers mes exemples, je supposerai que vous avez votre clé privée située à/home/user/.ssh/jenkins

Erreur à éviter : La valeur GIT_SSH comprend les options

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

ou tout autre élément similaire échouera, car git essaiera d'exécuter la valeur sous forme de fichier. Pour cette raison, vous devez créer un script.

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

Le script sera invoqué comme suit :

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

Exemple de fonctionnement du script pourrait ressembler à :

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

Notez le $* à la fin, il en constitue une partie importante. Une alternative encore plus sûre, qui empêcherait tout conflit possible avec tout ce qui se trouve dans votre fichier de configuration par défaut (plus la mention explicite du port à utiliser) serait :

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

En supposant que le script soit dans /home/user/gssh.sh, vous devez alors :

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

et tout doit fonctionner.

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

Vous pouvez en savoir plus à l'adresse https://github.com/ccontavalli/ssh-ident

Il charge les clés ssh à la demande au premier besoin, une seule fois, même avec plusieurs sessions de connexion, xterms ou NFS shared homes.

Avec un minuscule fichier de configuration, il peut automatiquement charger différentes clés et les garder séparées dans différents agents (pour le transfert d'agent) en fonction de ce que vous devez faire.

J'avais un client qui avait besoin d'un compte github séparé. J'ai donc dû utiliser une clé séparée pour ce seul 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.

J'ai donc défini la variable GIT_SSH env à $HOME/bin/git-ssh.

Afin de permettre à ma configuration de repo de dicter l'identité ssh à utiliser, mon fichier ~/bin/git-ssh est le suivant :

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

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

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

Et dans n'importe quel dépôt git, je peux juste définir une valeur de configuration git locale :

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

Voila ! Si vous pouvez avoir une adresse électronique différente pour chaque identité, c'est encore plus simple, car vous pouvez simplement nommer vos clés d'après vos adresses électroniques et demander à user.email de git config de sélectionner la clé dans un ssh.identity comme ceci :

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

Je m'appuie sur @shellholic et ce fil SO avec quelques tecks. J'utilise GitHub comme exemple et suppose que vous avez une clé privée dans ~/.ssh/github (sinon, voir this SO thread ) et que vous avez ajouté la clé publique à votre profil GitHub (sinon, voir GitHub’s help ). Si nécessaire, créez un nouveau fichier de configuration SSH dans ~/.ssh/config et modifiez les permissions à 400

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

Ajoutez ceci au fichier ~/.ssh/config :

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

Si vous avez déjà une configuration à distance, vous pouvez la supprimer, sinon vous risquez de devoir encore fournir un nom d'utilisateur et un mot de passe :

git remote rm origin

Ensuite, ajoutez une télécommande au dépôt git, et remarquez les deux points avant le nom d'utilisateur :

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

Et puis les commandes git fonctionnent normalement, e. g. :

git push origin master
git pull origin

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

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

puis quand vous devez changer le var run :

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

N'oubliez pas le point supplémentaire !! cela fait que le script définit les environnements vars ! –key et –port sont optionnels.

En général, vous voulez utiliser ~/.ssh/config pour cela. Il suffit de coupler les adresses des serveurs avec les clés que vous voulez utiliser pour eux 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ésigne n'importe quel serveur, donc je l'utilise pour définir ~/.ssh/id_rsa comme la clé par défaut à utiliser.

Il suffit d'utiliser les commandes ssh-agent et 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>

Après avoir exécuté les commandes ci-dessus, vous pouvez utiliser les deux touches en même temps. Il suffit de taper

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

pour cloner votre dépôt.

Vous devez exécuter la commande ci-dessus après avoir redémarré votre machine.

# 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

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 juste spécifiquement pour gitlab .

La solution gitlab

J'ai essayé d'utiliser l'approche variables environnementales , mais même la documentation de git recommande d'utiliser ~/.ssh/config pour tout ce qui est plus que le simple cas. Dans mon cas, j'utilise 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 mis en œuvre, je procède simplement comme suit :

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

Setup

Recall the location of your private-key /myfolder/.ssh/my_gitlab_id_rsa in my case.

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

Ajouter 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, je effectue mes commits sur ce même hôte en tant qu'utilisateur spécifique avec ce git-alias : Tout ce qui précède suppose que le serveur distant concerné est origin et que la branche concernée est actuellement vérifiée. Pour référence, je suis tombé sur plusieurs points qui devaient être abordés :

• La solution nécessite la création d'une nouvelle télécommande gitlab_as_me, et je n'aimais pas voir la télécommande supplémentaire qui traînait dans mon arbre de logs donc je la supprime une fois 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 frappe cut
• Lorsque vous effectuez un push vers gitlab_as_me, vous devez être précis sur la branche que vous poussez
• Après avoir effectué le push, votre pointeur local origin doit être “mis à jour” afin de correspondre à gitlab_as_me (c'est ce que fait git pull origin $branch)

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

Vous devez suivre la même étape pour générer la clé ssh, mais assurez-vous que vous

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

Entrez le chemin que vous voulez enregistrer (Ex : mon-pc/Desktop/. ssh/ed25519)

Ajouter la clé publique à votre gitlab Comment ajouter la clé ssh à votre gitlab )

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

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

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.

• J'ai juste copié ma clé privée dans .ssh/id_rsa
• je règle les permissions sur 600

Et git lit la clé automatiquement. Je ne demande rien et cela ne provoque pas d'erreur. Il fonctionne juste bien.

Si vous avez besoin de vous connecter au même hôte avec des clés différentes, vous pouvez le faire par :

1. Configurer le ~/.ssh/config avec différents hôtes mais avec les mêmes noms d'hôtes.
2. Clonez votre repo en utilisant l'hôte approprié.

Exemple :

~/.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

Puis à la place clonez vos repo comme :

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

vous devez faire

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