sshtiene la -iopción de indicar qué archivo de clave privada usar al autenticar:

-i identity_file

Selecciona un archivo del que se lee la identidad (clave privada) para la autenticación RSA o DSA. El valor predeterminado es ~/.ssh/identitypara la versión 1 del protocolo ~/.ssh/id_rsay ~/.ssh/id_dsapara la versión 2 del protocolo. Los archivos de identidad también pueden especificarse por host en el archivo de configuración. Es posible tener múltiples -iopciones (y múltiples identidades especificadas en los archivos de configuración).

¿Hay una manera similar de saber gitqué archivo de clave privada usar en un sistema con múltiples claves privadas en el ~/.sshdirectorio?

En ~/.ssh/config, agregue:

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

Ahora puedes hacerlo git clone [email protected]:username/repo.git.

NOTA: Verifique que los permisos en IdentityFile sean 400. SSH rechazará, de una manera no claramente explícita, las claves SSH que son demasiado legibles. Simplemente se verá como un rechazo de credenciales. La solución, en este caso, es:

chmod 400 ~/.ssh/id_rsa_github

Variable de entorno GIT_SSH_COMMAND:

Desde Git versión 2.3.0, puede usar la variable de entorno GIT_SSH_COMMANDcomo esta:

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

Tenga en cuenta que a -iveces puede ser anulado por su archivo de configuración, en cuyo caso, debe darle a SSH un archivo de configuración vacío, como este:

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

Configuración core.sshCommand:

¡Desde Git versión 2.10.0, puede configurar esto por repositorio o globalmente, por lo que ya no tiene 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 una forma directa de saber gitqué clave privada usar, ya que depende sshde la autenticación del repositorio. Sin embargo, todavía hay algunas maneras de lograr su objetivo:

Opción 1: ssh-agent

Puede usar ssh-agentpara autorizar temporalmente su clave privada.

Por ejemplo:

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

Opcion 2: GIT_SSH_COMMAND

Pase los argumentos ssh utilizando la GIT_SSH_COMMANDvariable de entorno (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

_{Puede escribir todo esto en una línea: ignore $y omita el \.}

Opcion 3: GIT_SSH

Pase los argumentos ssh utilizando la GIT_SSHvariable de entorno para especificar sshbinarios alternativos .

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 debe pegar en su terminal. Crearán un archivo llamado ssh, lo harán ejecutable y (indirectamente) lo ejecutarán.}

^{Nota: GIT_SSHestá disponible desde v0.99.4 (2005).}

Opcion 4: ~/.ssh/config

Utilice el ~/.ssh/configarchivo como se sugiere en otras respuestas para especificar la ubicación de su clave privada, p. Ej.

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

Escriba una secuencia de comandos que llame sshcon los argumentos que desee y coloque el nombre de archivo de la secuencia de comandos $GIT_SSH. O simplemente ponga su configuración ~/.ssh/config.

Si no desea tener que especificar variables de entorno cada vez que ejecuta git, no desea otro script de contenedor, no puede / no puede ejecutar ssh-agent (1), ni desea descargar otro paquete solo para esto, use el git -remote-ext (1) transporte externo:

$ 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 repositorio / remoto específico
• Evite la hinchazón del script de envoltura
• No necesita el agente SSH: útil si desea clones / push / pull desatendidos (por ejemplo, en cron)
• Definitivamente, no se necesita herramienta externa

Utilice la configuración de host personalizada ~/.ssh/config, como esta:

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

luego use su nombre de host personalizado como este:

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

Después de mi lucha, $GIT_SSHme gustaría compartir lo que funcionó para mí.

A través de mis ejemplos, asumiré que tiene su clave privada ubicada en/home/user/.ssh/jenkins

Error a evitar: el valor GIT_SSH incluye opciones

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

o cualquier error similar, ya que git intentará ejecutar el valor como un archivo . Por esa razón, tienes que crear un script.

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

El script se invocará de la siguiente manera:

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

El funcionamiento del script de muestra podría verse así:

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

Tenga $*en cuenta que al final, es una parte importante de la misma.

Una alternativa aún más segura, que evitaría cualquier posible conflicto con cualquier cosa en su archivo de configuración predeterminado (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 $*

Suponiendo que el guión esté dentro /home/user/gssh.sh, usted deberá:

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

y todo funcionará.

Puede usar ssh-ident en lugar de crear su propio contenedor.

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

Carga las claves ssh a pedido cuando se necesita por primera vez, una vez, incluso con múltiples sesiones de inicio de sesión, xterms o hogares compartidos 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 necesite hacer.

Tenía un cliente que necesitaba una cuenta de github separada. Así que necesitaba usar una clave separada solo para este proyecto.

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

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

Cada vez que quiero usar git para ese proyecto, reemplazo "infogit" con git:

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

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

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

Para permitir que mi configuración de repositorio dicte qué identidad ssh usar, mi ~/bin/git-ssharchivo es este:

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

Luego tengo una configuración de configuración global de git:

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

Y dentro de cualquier repositorio de git, solo puedo establecer un ssh.identityvalor de configuración de git local :

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

Voila!

Si puede tener una dirección de correo electrónico diferente para cada identidad, se vuelve aún más simple, porque solo puede nombrar sus claves después de sus direcciones de correo electrónico y luego hacer que el usuario email de git config maneje la selección de claves de ~/bin/git-sshesta manera:

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

Mi solución fue esta:

crear un guión:

#!/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 tienes que cambiar la ejecución var:

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

¡No olvides el punto extra! esto hace que el script establezca los entornos vars !! --key y --port son opcionales.

Construyo sobre @shellholic y este hilo SO con unos cuantos tragos. Utilizo GitHub como ejemplo y supongo que tiene una clave privada ~/.ssh/github(de lo contrario, vea este hilo SO ) y que agregó la clave pública a su perfil de GitHub (de lo contrario, consulte la ayuda de GitHub ).

Si es necesario, cree un nuevo archivo de configuración SSH en ~/.ssh/configy cambie los permisos a 400

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

Agregue esto al ~/.ssh/configarchivo:

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

Si ya tiene una configuración remota, es posible que desee eliminarla; de lo contrario, es posible que se le solicite su nombre de usuario y contraseña:

git remote rm origin

Luego agregue un control remoto al repositorio git y observe los dos puntos antes del nombre de usuario:

git remote add origin [email protected]:user_name/repo_name.git

Y luego los comandos git funcionan normalmente, por ejemplo:

git push origin master
git pull origin 

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

En general, desea utilizar ~/.ssh/configpara esto. Simplemente empareje las direcciones del servidor 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_rsacomo la clave predeterminada para usar.

Solo usa ssh-agenty ssh-addcomandos.

# 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, puede usar ambas teclas al mismo tiempo. Sólo tipo

git clone [email protected]:<yourname>/<your-repo>.git

para clonar tu repositorio.

Debe ejecutar el comando anterior después de reiniciar su máquina.

Estoy usando git versión 2.16 y no necesito una sola secuencia de comandos, ni siquiera una configuración o comandos modificados.

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

Y git lee la tecla automáticamente. No pregunto nada y no arroja un error. Solo funciona bien.

Si bien la pregunta no lo solicita, incluyo esta respuesta para cualquier persona que busque resolver el mismo problema específicamente para gitlab .

La solución de gitlab

Intenté usar el enfoque de variables de entorno , pero incluso la documentación de git recomienda usar ~/.ssh/configpara algo más que el caso simple. En mi caso, estoy presionando a un servidor gitlab , y quería hacerlo como un usuario específico, que por supuesto se define mediante la clave privada durante la autenticación y no el nombre de usuario git. Una vez implementado, simplemente realizo lo siguiente:

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

Preparar

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

Agregar una entrada en ~/.ssh/config:

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

Agrega 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 beneficio adicional, realizo mis confirmaciones en este mismo host como un usuario específico con este git-alias :

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

Explicación

Todo lo anterior supone que el control remoto relevante es originy la rama relevante está actualmente desprotegida. Como referencia me encontré con varios elementos que debían abordarse:

• La solución requiere crear un nuevo control remoto gitlab_as_me, y no me gustó ver el control remoto adicional colgando en mi árbol de registro, así que lo elimino cuando termine
• Para crear el control remoto, es necesario generar la url del control remoto sobre la marcha; en el caso de gitlab, esto se logró con un simple corte de bash
• Al realizar un impulso gitlab_as_me, debe ser específico sobre qué rama está presionando
• Después de realizar el empuje, su originpuntero local debe ser "actualizado" para que coincida gitlab_as_me( git pull origin $branchesto lo hace)

Cuando tienes varias cuentas git y quieres una clave ssh diferente

Debe seguir el mismo paso para generar la clave ssh, pero asegúrese de

ssh-keygen -t ed25519 -C "[email protected]" 

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

Agregue la clave pública a su gitlab ( Cómo agregar clave ssh a gitlab )

Tienes que crear una nueva identidad ssh usando el siguiente comando

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