En ~/.ssh/config, añade:

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

Si el archivo de configuración es nuevo, no te olvides de hacer chmod 600 ~/.ssh/config

Ahora puedes hacer git clone git@github.com:{ORG_NAME}/{REPO_NAME}.git

• Donde {ORG_NAME} es el nombre de la URI de tu cuenta de usuario GitHub (o cuenta de la organización).
• Ten en cuenta que hay dos puntos : después de github.com en lugar de la barra inclinada /, ya que no es una URI.
• Y {REPO_NAME} es el nombre de URI de tu repo GitHub
• Por ejemplo, para el núcleo de Linux sería git clone git@github.com:torvalds/linux.git).

NOTA: En Linux y macOS, verifica que los permisos de tu IdentityFile son 400. SSH rechazará, de manera no claramente explícita, las claves SSH que sean demasiado legibles. Sólo parecerá un rechazo de credenciales. La solución, en este caso, es:

chmod 400 ~/.ssh/id_rsa_github

Variable de entorno GIT_SSH_COMMAND:

A partir de la versión 2.3.0 de Git, puedes usar la variable de entorno GIT_SSH_COMMAND así:

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

Nota que -i a veces puede ser anulada por tu archivo de configuración, en cuyo caso, debes darle a SSH un archivo de configuración vacío, así:

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

Configuración core.sshCommand:

A partir de la versión 2 de Git. 10.0, puedes configurarlo por repo o globalmente, ¡así que ya no tienes que configurar la variable de entorno!

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

No hay no hay una manera _directa de decirle a git qué clave privada usar, porque se basa en ssh para la autentificación del repositorio. Sin embargo, todavía hay algunas formas de conseguir tu objetivo:

Opción 1: ssh-agent

Puedes usar ssh-agent para autorizar temporalmente tu clave privada.

Por ejemplo:

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

Opción 2: GIT_SSH_COMMAND

Pasa los argumentos ssh usando la variable de entorno GIT_SSH_COMMAND (Git 2.3.0+).

Por ejemplo:

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

Puedes escribir todo esto en una línea -ignorar $ y dejar fuera el No hay **no hay una manera _directa** de decirle agitqué clave privada usar, porque se basa enssh` para la autentificación del repositorio. Sin embargo, todavía hay algunas formas de conseguir tu objetivo:

Opción 1: ssh-agent

Puedes usar ssh-agent para autorizar temporalmente tu clave privada.

Por ejemplo:

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

Opción 2: GIT_SSH_COMMAND

Pasa los argumentos ssh usando la variable de entorno GIT_SSH_COMMAND (Git 2.3.0+).

Por ejemplo:

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

Puedes escribir todo esto en una línea -ignorar $ y dejar fuera el .

Opción 3: GIT_SSH

Pasa los argumentos ssh usando la variable de entorno GIT_SSH para especificar el binario alternativo ssh.

Por ejemplo:

$ 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: Las líneas anteriores son líneas de comando de shell (terminal) que deberías pegar en tu terminal. Crearán un archivo llamado ssh, lo harán ejecutable y (indirectamente) lo ejecutarán.

Nota: GIT_SSH está disponible desde v0.99.4 (2005).

Opción 4: ~/.ssh/config

Utilice el archivo ~/.ssh/config como se sugiere en otras respuestas para especificar la ubicación de su clave privada, por ejemplo

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

Escribe un guión que llame a ssh con los argumentos que quieras, y pon el nombre de archivo del guión en $GIT_SSH. O simplemente pon tu configuración en ~/.ssh/config.

Use la configuración personalizada del host en ~/.ssh/config, así:

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

y luego use su nombre de host personalizado así:

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

Si no quieres tener que especificar variables de entorno cada vez que corras git, no quieres otro script de envoltura, no/puedes ejecutar ssh-agent(1), ni quieres descargar otro paquete sólo para esto, usa el transporte externo 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 que esta solución es superior porque:

• Es específica del repositorio/remoto
• Evita la hinchazón del script wrapper
• No necesito el agente SSH – útil si quieres clones/empujes/tiradores desatendidos (e. g. en cron)
• Definitivamente, no se necesita ninguna herramienta externa

Después de mi lucha con $GIT_SSH me gustaría compartir lo que me ha funcionado.

A través de mis ejemplos asumiré que tienes tu llave privada localizada en /home/user/.ssh/jenkins

Error a evitar: El valor de GIT incluye las opciones

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

o lo que sea que falle, ya que git intentará ejecutar el valor como un archivo. Por esa razón, debes crear un script.

Ejemplo de trabajo del script $GIT_SSH /home/user/gssh.sh

El script será invocado de la siguiente manera:

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

El ejemplo de trabajo del script podría ser como:

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

Nota el $* al final, es parte importante de él.

Una alternativa aún más segura, que evitaría cualquier posible conflicto con cualquier cosa en su archivo de configuración por defecto (además de mencionar explícitamente el puerto a usar) sería:

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

Asumiendo que el script está en /home/user/gssh.sh, entonces:

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

y todo funcionará.

Puedes usar ssh-ident en lugar de crear tu propio envoltorio.

Puedes leer más en: https://github.com/ccontavalli/ssh-ident

Carga las claves ssh a petición cuando se necesitan por primera vez, una vez, incluso con múltiples sesiones de inicio de sesión, xterms o casas compartidas de NFS.

Con un pequeño archivo de configuración, puede cargar automáticamente diferentes claves y mantenerlas separadas en diferentes agentes (para el reenvío de agentes) dependiendo de lo que necesites hacer.

Tenía un cliente que necesitaba una cuenta github separada. Así que necesitaba usar una clave separada sólo para este proyecto.

Mi solución fue añadir esto a mi .zshrc / .bashrc:

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

Siempre que quiero usar git para ese proyecto reemplazo “infogit” por git:

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

Para mí, es más fácil de recordar.

Así que puse la variable env GIT_SSH en $HOME/bin/git-ssh.

Para soportar que mi configuración de repo dicte qué identidad ssh usar, mi archivo ~/bin/git-ssh es este:

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

Entonces tengo una configuración global de git:

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

Y dentro de cualquier repositorio git puedo establecer un valor de configuración local ssh.identity git:

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

¡Voilà! Si puedes tener una dirección de correo electrónico diferente para cada identidad, se vuelve aún más simple, porque puedes nombrar tus claves después de tus direcciones de correo electrónico y luego hacer que el user.email de la configuración de git maneje la selección de claves en un ~/bin/git-ssh así:

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

Me baso en @shellholic y este hilo de SO con unos cuantos tés. Uso GitHub como ejemplo y asumo que tienes una clave privada en ~/.ssh/github (de lo contrario, ver este hilo SO) y que has añadido la clave pública a tu perfil de GitHub (de lo contrario, ver ayuda de GitHub).

Si es necesario, crea un nuevo archivo de configuración SSH en ~/.ssh/config y cambia los permisos a 400

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

Añade esto al archivo ~/.ssh/config:

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

Si ya tienes una configuración remota, puede que quieras eliminarla, de lo contrario puede que se te pida el nombre de usuario y la contraseña:

git remote rm origin

Entonces añade un remoto al repositorio de git, y fíjate en los dos puntos antes del nombre de usuario:

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

Y entonces los comandos de git funcionan normalmente, e. g.:

git push origin master
git pull origin

@HeyWatchEste en este hilo SO sugirió agregar IdentitiesOnly yes para evitar que el comportamiento por defecto de SSH de enviar el archivo de identidad coincida con el nombre de archivo por defecto de cada protocolo. Vea ese hilo para más información y referencias.

Mi solución fue esta:

crear 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

entonces cuando tengas que cambiar la corrida del var:

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

¡¡No te olvides del punto extra!! esto hace que el script establezca los ambientes vars! –key y –port son opcionales.

Generalmente, quieres usar ~/.ssh/config para esto. Simplemente empareje las direcciones de los servidores con las claves que desea utilizar para ellos de la siguiente manera:

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

Host * denota cualquier servidor, por lo que lo uso para establecer ~/.ssh/id_rsa como la clave por defecto a utilizar.

Sólo usa los comandos ssh-agent y 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>

Después de ejecutar los comandos anteriores, puedes usar ambas teclas al mismo tiempo. Sólo tienes que escribir

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

para clonar tu repositorio.

Necesitas ejecutar el comando anterior después de reiniciar tu máquina.

# 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

Aunque la pregunta no lo pide, incluyo esta respuesta para cualquier otra persona que busque resolver el mismo problema sólo específicamente para gitlab .

La solución del gitlab

Intenté usar el enfoque de variables de entorno , pero incluso la documentación del git recomienda usar ~/.ssh/config para cualquier cosa más que el simple caso. En mi caso estoy empujando a un servidor gitlab - y quería hacerlo como un usuario específico - que por supuesto está definido por la clave privada durante la autenticación y no el nombre de usuario git. Una vez implementado, simplemente hago lo siguiente:

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

Setup

Recordar la ubicación de su clave privada /myfolder/.ssh/my_gitlab_id_rsa en mi caso.

Añade una entrada en ~/.ssh/config:

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

Añade el git-alias en ~/.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"

Como bonus, yo realizo mis commits en este mismo host como un usuario específico con este git-alias :

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

Explicación

Todo lo anterior asume que el remoto relevante es origin y la rama relevante está actualmente comprobada. Para referencia me encontré con varios elementos que necesitaban ser abordados:

• La solución requiere la creación de un nuevo remoto gitlab_as_me, y no me gustó ver el remoto extra colgando en mi árbol de troncos así que lo quité cuando terminé
• Para crear el remoto, hay una necesidad de generar la url del remoto sobre la marcha - en el caso de gitlab esto se logró con un simple bash corte
• Al realizar un empuje a gitlab_as_me necesitas ser específico acerca de qué rama estás empujando
• Después de realizar el empuje tu puntero local origin necesita ser “actualizado” para que coincida con gitlab_as_me (el git pull origin $branch hace esto)

Cuando tienes varias cuentas git y quieres una clave ssh diferente

Tienes que seguir el mismo paso para generar la clave ssh, pero asegúrate de

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

Introducir la ruta que quieres guardar(Ej: my-pc/Desktop/. ssh/ed25519)

Añadir la clave pública a tu gitlab Cómo añadir la clave ssh a gitlab )

Tienes que crear una nueva identidad ssh usando el siguiente comando

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

Estoy usando la versión 2.16 de git y no necesito un solo script, ni siquiera una configuración o comandos modificados.

• Acabo de copiar mi clave privada a .ssh/id_rsa
• establecer los permisos a 600

Y git lee a la clave automáticamente. No pido nada y no da ningún error. Simplemente funciona bien.

Si necesitas conectarte al mismo host con diferentes claves, puedes hacerlo por:

1. Configure el ~/.ssh/config con diferentes hosts pero con los mismos nombres de host.
2. 2. Clonar su repositorio utilizando el host apropiado.

Ejemplo:

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

Entonces en lugar de clonar su repositorio como:

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

debe hacer

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