Comment dire à git quelle clé privée utiliser?

648

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?

Jrdioko
la source
3
Voir cette question dans StackOverflow également.
Flimm
2
Également lié au serverfault.com/questions/194567/…
Machavity le

Réponses:

674

Dans ~/.ssh/config, ajoutez:

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

Maintenant vous pouvez faire git clone [email protected]: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
shellholic
la source
117
Et si vous avez besoin de vous connecter au même hôte avec des clés différentes?
Valentin Klinghammer
6
@Quelltextfabrik - vous pouvez ajouter une autre section avec un hôte différent: nerderati.com/2011/03/…
Ben Challenor
1
@Cliff Nop, in my man page: " HostName: Spécifie le nom d'hôte réel auquel se connecter. Ceci peut être utilisé pour spécifier des pseudonymes ou des abréviations pour les hôtes." Ma version ssh est openssh-6.7p1.
Grissiom
11
Si le fichier de configuration est nouveau, n'oubliez pas de le fairechmod 600 ~/.ssh/config
elysch
2
@ ValentinKlinghammer la réponse de @Flimm a la solution pour cette question. C'est utiliser la core.sshCommandconfiguration de git. superuser.com/a/912281/162466
VasyaNovikov
345

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
Flimm
la source
1
J'ai dû exporter la variable shell en une variable d'environnement pour que cela fonctionne, c'est export GIT_SSH_COMMAND="ssh -i ~/.ssh/id_rsa_example"-à- diregit clone example
Abdull
7
@Abdull Dans Bash, l'affectation sur la même ligne que la commande exporte la variable d'environnement pour cette commande uniquement. Essayez: example=hello /usr/bin/env | grep example.
Flimm le
3
les choses sont encore meilleures: à partir de Git 2.10, vous pouvez stocker la commande dans votre configuration Git: stackoverflow.com/a/38474220/520162
eckes
2
@Noitidart /dev/nulln'est qu'un nom de fichier valide dans les systèmes d'exploitation de type UNIX, il ne fonctionne pas sous Windows.
Flimm
2
Pour moi , GIT_SSH_COMMANDne fonctionnait pas jusqu'à ce que je IdentitiesOnly, comme cette commande: GIT_SSH_COMMAND="ssh -i ~/.ssh/mysubdir/id_rsa -o 'IdentitiesOnly yes'" git push.
Tyler Collier
112

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
Kenorb
la source
1
//, Et si votre identité dans ssh-agent est transmise, comme dans cette question? superuser.com/questions/971732/…
Nathan Basanese
1
Je me suis permis de reformater ce post: IMO c'est de loin la réponse la plus complète. Dans sa conception originale, une analyse rapide suggérait que le poste décrivait une solution complexe au problème, alors je l’ai manquée.
Alberto
3
$ ssh-agent sh -c 'ssh-add ~/.ssh/id_rsa; git fetch user@host'travaillé pour moi quand rien d'autre ne le ferait. Gloire.
Daniel Dewhurst
1
J'ai dû utiliser la ~/.ssh/configméthode, env vars n'a pas fonctionné pour moi ...
Greg Dubicki
1
GIT_SSHest disponible depuis v0.99.4 (août 2005) , donc depuis que Git existe (avril 2005).
Dominik
32

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.

Ignacio Vazquez-Abrams
la source
2
Une autre explication sur la façon de procéder.
Sithsu
1
~/.ssh/configEst le chemin à parcourir.
hek2mgl
Je travaille sur une machine (A) à partir de laquelle je suis git push sur un serveur (B) qui accepte uniquement l’authentification par clé ssh. Bien que ma configuration de ~ / .ssh / config sous (A) fonctionne parfaitement lorsque je travaille directement sur cette machine, cela ne fonctionne pas lorsque je me connecte depuis un autre emplacement (C). L'utilisation d' $GIT_SSHun script a résolu ce problème. Merci!
bsumirak
19

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
flaviovs
la source
2
Cette réponse était exactement ce dont j'avais besoin pour forcer la gitressource Chef à utiliser des clés de déploiement spécifiques au référentiel pour cloner / extraire des référentiels Github privés. L’avantage supplémentaire de cette méthode par rapport aux méthodes basées sur l’environnement et les scripts est que, puisque le chemin de clé est codé dans la configuration du référentiel de travail, elle utilisera la même clé lors du clonage initial et des extractions / poussées ultérieures.
Adam Franco
2
HOU LA LA! C'est juste génial, je ne savais pas à ce sujet. Merci pour la réponse, très utile aussi dans les environnements de marionnettes, pour éviter les tracas supplémentaires à gérer, .ssh/configetc. +1!
gf_
1
Cette solution ne fonctionne pas avec l'indicateur --recursive. Les sous-modules ne sont pas récupérés à l'aide de la clé spécifiée et échouent par conséquent s'ils nécessitent une autorisation.
Daniele Testa
1
Chaque sous-module est un référentiel totalement différent, avec son propre ensemble de télécommandes. Elles sont collées par Git pour votre commodité, mais en aucun cas les télécommandes d’un sous-module ne sont liées à celles du référentiel parent. Je crains que vous ne deviez configurer la télécommande en utilisant le exttransport dans chaque sous-module pour que la récursion dans le parent fonctionne.
flaviovs
2
Si vous rencontrez l'erreur suivante fatal: transport 'ext' not allowed, vous devez ajouter le protocole ext à la liste blanche via export GIT_ALLOW_PROTOCOL=ext. Fondamentalement, l’assistant distant git-remote-ext (qui prend en charge les URL "ext :: ssh exemple.com% S foo / repo") permet l’exécution de commandes arbitraires. Normalement, cela ne pose aucun problème, car l'utilisateur voit et fait toujours confiance à l'URL qu'il transmet à git. Cependant, les sous-modules git, via le fichier .gitmodules, permettent à un attaquant de demander au client de récupérer des URL git arbitraires. hackerone.com/reports/104465
Gomino
18

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  
Thucnguyen
la source
2
C’est la réponse que je cherchais, car j’ai des comptes GitHub distincts pour la maison et le travail. Il me Host work.github.com HostName github.com IdentityFile ~/.ssh/worksuffisait de définir , puis de remplacer "github.com" par "work.github.com" à chaque fois que je clonais un référentiel de travail. Il se connecte toujours à "github.com", mais en utilisant une paire de clés autre que celle par défaut.
Mikkel
1
L'URL pour plus de détails (" itblog.study.land / ..." ) ne fonctionne plus :(
Carl Smotricz
@CarlSmotricz l'original a été déplacé ici: medium.com/@thucnc/…
thucnguyen
4
ENFIN!!! Cette réponse montre en fait comment vous pouvez utiliser ce que vous avez mis dans le ~/.ssh/configfichier. Toute autre réponse ignore comment vous pouvez définir l'hôte lorsque vous ajoutez l'origine, ce qui permet automatiquement à git d'utiliser le fichier de clé correct. MERCI!!
BrianVPS
1
Bien, c'était ce que je cherchais :)
Lucas D'Avila
15

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.

Jan Vlcinsky
la source
Merci. Remarque: utilisez "$ @" au lieu de $ * pour les arguments directs, car le premier se comporte correctement lorsque les arguments contiennent des espaces.
Piotr Findeisen
@PiotrFindeisen Merci pour votre note. Cependant, je ne le comprends pas tout à fait - en zsh cela m'aide à garder les chaînes avec de l’espace en un seul morceau, mais pas en bash. Pouvez-vous m'en dire plus ou donner des explications? Je ne veux pas ajouter une modification à l'aveuglette.
Jan Vlcinsky
Vous devriez supprimer la première moitié de votre réponse. Personne ne s'intéresse à une solution qui ne fonctionne pas et à une lecture gaspillée qui obscurcit la bonne réponse en bas, ce qui fonctionne à merveille.
Cerin
@Cerin Si vous voulez supprimer "l'erreur à éviter", je vais la garder là. Il partage un piège commun à éviter et il est très court. Je suis sûr que quelqu'un essaierait d'optimiser la solution en fournissant tout ce qui était variable (c'est ce qui m'est arrivé), alors j'ai essayé de raccourcir la voie du succès.
Jan Vlcinsky
5

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.

rabexc
la source
5

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.

Michael Cole
la source
4

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 $*
Brendan Baldwin
la source
2

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.

Salsicha
la source
2

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.

Zaz
la source
2

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 [email protected]: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.

miguelmorin
la source
Ce fut mon erreur: "Si vous avez déjà une télécommande configurée ...". Merci beaucoup!!!
Allan Andrade
erreur commune --- c'est la réponse
Goddard
1

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 [email protected]:<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.

Jinmiao Luo
la source
S'il vous plaît expliquer le processus, y compris Comment puis-je créer un agent
Srikrushna
0

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.

akprajapati
la source
Avez-vous remarqué que la question concerne «un système avec plusieurs clés privées dans le ~/.sshrépertoire»?
Scott
0

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

La solution gitlab

J'ai essayé d'utiliser l' approche des , 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 - et je voulais le faire en tant qu'utilisateur spécifique - qui est bien sûr défini par la lors de l' 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 /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 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 :

mycommit = "!f() { \
             git -c "user.name=myname" -c "[email protected]" 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 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)
Dtmland
la source
0

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 "[email protected]" 

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
Srikrushna
la source
(1) Citez-vous quelqu'un ou quelque chose? Si oui, veuillez identifier la source. Si ce n'est pas le cas, n'utilisez pas le formatage des guillemets. (2) Qu'est-ce que c'est «ed25519»? ……………………………… S'il vous plaît ne répondez pas dans les commentaires; éditez  votre réponse pour la rendre plus claire et plus complète.
Scott le
0
    # start :: how-to use different ssh identity files

    # create the company identity file
    ssh-keygen -t rsa -b 4096 -C "[email protected]"
    # 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 "[email protected]"
    # 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 [email protected]: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 <[email protected]>"
    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 [email protected]: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 <[email protected]>"
    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
Yordan Georgiev
la source