¿Cómo especificar la clave SSH privada para usar al ejecutar el comando de shell en Git?

Tal vez una situación bastante inusual, pero quiero especificar una clave SSH privada para usar al ejecutar un comando de shell (git) desde la computadora local.

Básicamente así:

git clone git@github.com:TheUser/TheProject.git -key "/home/christoffer/ssh_keys/theuser"

O incluso mejor (en Ruby):

with_key("/home/christoffer/ssh_keys/theuser") do
  sh("git clone git@github.com:TheUser/TheProject.git")
end

He visto ejemplos de conexión a un servidor remoto con Net :: SSH que usa una clave privada especificada, pero este es un comando local. ¿Es posible?

Algo como esto debería funcionar (sugerido por orip):

ssh-agent bash -c 'ssh-add /somewhere/yourkey; git clone git@github.com:user/project.git'

si prefiere subcapas, puede intentar lo siguiente (aunque es más frágil):

ssh-agent $(ssh-add /somewhere/yourkey; git clone git@github.com:user/project.git)

Git invocará SSH que encontrará su agente por variable de entorno; Esto, a su vez, tendrá la clave cargada.

Alternativamente, la configuración HOMEtambién puede ser útil, siempre que esté dispuesto a configurar un directorio que contenga solo un .sshdirectorio como HOME; esto puede contener un identity.pub o un archivo de configuración que configura IdentityFile.

Ninguna de estas soluciones funcionó para mí.

En cambio, me explayé sobre la mención de @Martin v. Löwis de configurar un configarchivo para SSH.

SSH buscará el ~/.ssh/configarchivo del usuario . Tengo la configuración mía como:

Host gitserv
    Hostname remote.server.com
    IdentityFile ~/.ssh/id_rsa.github
    IdentitiesOnly yes # see NOTES below

Y agrego un repositorio remoto de git:

git remote add origin git@gitserv:myrepo.git

Y luego los comandos git funcionan normalmente para mí.

git push -v origin master

NOTAS

• Se IdentitiesOnly yesrequiere para evitar el comportamiento predeterminado de SSH de enviar el archivo de identidad que coincide con el nombre de archivo predeterminado para cada protocolo. Si tiene un archivo llamado ~/.ssh/id_rsaque se probará ANTES de su ~/.ssh/id_rsa.githubsin esta opción.

Referencias

• La mejor manera de usar múltiples claves privadas SSH en un cliente
• ¿Cómo podría dejar de ofrecer una clave incorrecta?

A partir de Git 2.3.0 también tenemos el comando simple (no se necesita un archivo de configuración):

GIT_SSH_COMMAND='ssh -i private_key_file' git clone user@host:repo.git

Las sugerencias de otras personas ~/.ssh/configson muy complicadas. Puede ser tan simple como:

Host github.com
  IdentityFile ~/.ssh/github_rsa

Contenido de my_git_ssh_wrapper:

#!/bin/bash

ssh -i /path/to/ssh/secret/key $1 $2

Luego puede usar la clave haciendo:

GIT_SSH=my_git_ssh_wrapper git clone git@github.com:TheUser/TheProject.git

Con git 2.10+ (Q3 2016: lanzado el 2 de septiembre de 2016), tiene la posibilidad de establecer una configuración para GIT_SSH_COMMAND(y no solo una variable de entorno como se describe en la respuesta de Rober Jack Will )

Ver commit 3c8ede3 (26 de junio de 2016) por Nguyễn Thái Ngọc Duy ( pclouds) .
^{(Fusionada por Junio ​​C Hamano - gitster- en commit dc21164 , 19 jul 2016)}

Se core.sshCommandha agregado una nueva variable de configuración para especificar qué valor GIT_SSH_COMMANDusar por repositorio.

core.sshCommand:

Si esta variable está configurada git fetchy git pushusará el comando especificado en lugar de sshcuándo necesitan conectarse a un sistema remoto.
El comando tiene la misma forma que la GIT_SSH_COMMANDvariable de entorno y se anula cuando se establece la variable de entorno.

Significa que git clonepuede ser:

cd /path/to/my/repo
git config core.sshCommand 'ssh -i private_key_file' 
# later on
git clone host:repo.git

Incluso puede configurarlo para un solo comando:

git -c core.sshCommand="ssh -i private_key_file" clone host:repo.git

Esto es más fácil de establecer una GIT_SSH_COMMANDvariable de entorno, que, en Windows, como se ha señalado por Mátyás-Kuti Kreszács , sería

set "GIT_SSH_COMMAND=ssh -i private_key_file"

Para resumir las respuestas y los comentarios , la mejor manera de configurar git para usar diferentes archivos clave y luego olvidarse de él, que también admite diferentes usuarios para el mismo host (por ejemplo, una cuenta personal de GitHub y una de trabajo), que funciona en Windows también, es editar ~/.ssh/config(o c:\Users\<your user>\.ssh\config) y especificar múltiples identidades:

Host github.com
HostName github.com
IdentityFile /path/to/your/personal/github/private/key
User dandv

Host github-work
HostName github.com
IdentityFile /path/to/your/work/github/private/key
User workuser

Luego, para clonar un proyecto como usuario personal, simplemente ejecute el git clone comando .

Para clonar el repositorio como workuser, ejecuta git clone git@github-work:company/project.git.

Como se indica aquí: https://superuser.com/a/912281/607049

Puede configurarlo por repo:

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

El problema es cuando tienes diferentes repositorios remotos en el mismo host (por ejemplo, github.com) y quieres interactuar con ellos usando diferentes claves ssh (es decir, diferentes cuentas de GitHub).

Para hacer eso:

1. Primero debe declarar sus diferentes claves en el ~/.ssh/configarchivo.

   # Key for usual repositories on github.com
   Host github.com
   HostName github.com
   User git
   IdentityFile ~/.ssh/id_rsa
   
   # Key for a particular repository on github.com
   Host XXX
   HostName github.com
   User git
   IdentityFile ~/.ssh/id_other_rsa

   Al hacer esto, asocia la segunda clave con un nuevo nombre descriptivo "XXX" para github.com.

2. Luego debe cambiar el origen remoto de su repositorio particular, para que use el nombre descriptivo que acaba de definir.

   Vaya a su carpeta de repositorio local dentro de un símbolo del sistema y muestre el origen remoto actual:

   >git remote -v
   origin  git@github.com:myuser/myrepo.git (fetch)
   origin  git@github.com:myuser/myrepo.git (push)

   Luego cambie el origen con:

   >git remote set-url origin git@XXX:myuser/myrepo.git
   >git remote -v
   origin  git@XXX:myuser/myrepo.git (fetch)
   origin  git@XXX:myuser/myrepo.git (push)

   Ahora puedes empujar, buscar ... con la tecla correcta automáticamente.

GIT_SSH_COMMAND="ssh -i /path/to/git-private-access-key" git clone $git_repo

o

export GIT_SSH_COMMAND="ssh -i /path/to/git-private-access-key"
git clone REPO
git push

Una idea mucho mejor para agregar ese host o ip al .ssh/configarchivo de esta manera:

Host (a space separated list of made up aliases you want to use for the host)
    User git
    Hostname (ip or hostname of git server)
    PreferredAuthentications publickey
    IdentityFile ~/.ssh/id_rsa_(the key you want for this repo)

Fui con la variable de entorno GIT_SSH. Aquí está mi contenedor, similar al de Joe Block desde arriba, pero maneja cualquier cantidad de argumentos.

Archivo ~ / gitwrap.sh

#!/bin/bash
ssh -i ~/.ssh/gitkey_rsa "$@"

Luego, en mi .bashrc, agregue lo siguiente:

export GIT_SSH=~/gitwrap.sh

Si ninguna de las otras soluciones aquí funciona para usted, y ha creado varias claves ssh, pero aún no puede hacer cosas simples como

git pull

luego, suponiendo que tenga dos archivos de clave ssh como

id_rsa
id_rsa_other_key

luego dentro del repositorio de git, intente:

# Run these commands INSIDE your git directory
eval `ssh-agent -s`
ssh-add ~/.ssh/id_rsa
ssh-add ~/.ssh/id_rsa_other_key

y también asegúrese de que su nombre de usuario y ID de usuario predeterminados de github sean correctos:

# Run these commands INSIDE your git directory
git config user.name "Mona Lisa"
git config user.email "mona.lisa@email.com"

Consulte https://gist.github.com/jexchan/2351996 para obtener más información.

Cuando es necesario conectar a github con una petición normal ( git pull origin master), estableciendo el anfitrión como *en el ~/.ssh/configtrabajado para mí, cualquier otro host (por ejemplo, "github" o "GB") no estaba funcionando.

Host *
    User git
    Hostname github.com
    PreferredAuthentications publickey
    IdentityFile ~/.ssh/id_rsa_xxx

Muchas de estas soluciones parecían atractivas. Sin embargo, encontré que el enfoque genérico git-wrapping-script en el siguiente enlace es el más útil:

Cómo especificar un archivo de clave ssh con el gitcomando

El punto es que no hay un gitcomando como el siguiente:

git -i ~/.ssh/thatuserkey.pem clone thatuser@myserver.com:/git/repo.git

La solución de Alvin es utilizar una secuencia de comandos bash-wrapper bien definida que llene este vacío:

git.sh -i ~/.ssh/thatuserkey.pem clone thatuser@myserver.com:/git/repo.git

Donde git.shes:

#!/bin/bash

# The MIT License (MIT)
# Copyright (c) 2013 Alvin Abad
# https://alvinabad.wordpress.com/2013/03/23/how-to-specify-an-ssh-key-file-with-the-git-command

if [ $# -eq 0 ]; then
    echo "Git wrapper script that can specify an ssh-key file
Usage:
    git.sh -i ssh-key-file git-command
    "
    exit 1
fi

# remove temporary file on exit
trap 'rm -f /tmp/.git_ssh.$$' 0

if [ "$1" = "-i" ]; then
    SSH_KEY=$2; shift; shift
    echo "ssh -i $SSH_KEY \$@" > /tmp/.git_ssh.$$
    chmod +x /tmp/.git_ssh.$$
    export GIT_SSH=/tmp/.git_ssh.$$
fi

# in case the git command is repeated
[ "$1" = "git" ] && shift

# Run the git command
git "$@"

Puedo comprobar que este resolvió un problema que estaba teniendo con el reconocimiento de usuario / clave para un acuerdo de recompra bitbucket remoto con git remote update, git pully git clone; todo lo cual ahora funciona bien en una cronsecuencia de comandos de trabajo que, de lo contrario, tenía problemas para navegar por el shell limitado. También pude llamar a este script desde R y aún resolver exactamente lo mismocron problema de ejecución (p. Ej.system("bash git.sh -i ~/.ssh/thatuserkey.pem pull") ).

No es que R sea lo mismo que Ruby, pero si R puede hacerlo ... O :-)

si tiene un directorio en su ruta donde desea firmar con un determinado archivo de identificación, puede especificar el uso de un archivo de identificación específico a través del archivo .ssh / config configurando, por ControlPathejemplo:

host github.com
  ControlPath ~/Projects/work/**
  HostName github.com
  IdentityFile ~/.ssh/id_work
  User git

Luego sshusará el archivo de identidad especificado al hacer comandos git bajo la ruta de trabajo dada.

Necesita crear un ~ / .ssh / config como se muestra a continuación

Host <Your bitbucket server>
User <userid>
Hostname <Your bitbucket server as above>
IdentitiesOnly yes
IdentityFile ~/.ssh/id_rsa<file> This is your private key file

permiso como abajo

-rw------- $HOME/.ssh/config

Agregue su clave pública en su git (cat ~ / .ssh / id_rsa_pub [o nombre similar])

y luego git clone como a continuación

git clone ssh://blahblah@blah.com/userid/test.git

Muchas buenas respuestas, pero algunas de ellas suponen conocimientos previos de administración.

Creo que es importante enfatizar explícitamente que si comenzaste tu proyecto clonando la URL de la web , https://github.com/<user-name>/<project-name>.git
entonces debes asegurarte de que el url valor debajo de [remote "origin"]en .git/config se haya cambiado a la URL de SSH (ver el bloque de código a continuación).

Además de eso, asegúrese de agregar lo sshCommmandque se menciona a continuación:

user@workstation:~/workspace/project-name/.git$ cat config
[core]
    repositoryformatversion = 0
    filemode = true
    bare = false
    logallrefupdates = true
    sshCommand = ssh -i ~/location-of/.ssh/private_key -F /dev/null <--Check that this command exist
[remote "origin"]
    url = git@github.com:<user-name>/<project-name>.git  <-- Make sure its the SSH URL and not the WEB URL
    fetch = +refs/heads/*:refs/remotes/origin/*
[branch "master"]
    remote = origin
    merge = refs/heads/master

Lea más sobre esto aquí .

En Windows con Git Bash puede usar lo siguiente para agregar un repositorio, ssh-agent bash -c 'ssh-add "key-address"; git remote add origin "rep-address"' por ejemplo: ssh-agent bash -c 'ssh-add /d/test/PrivateKey.ppk; git remote add origin git@git.test.com:test/test.git'Qué clave privada está en la unidad D, prueba de carpeta de la computadora. Además, si desea clonar un repositorio, puede cambiar git remote add origincongit clone .

Después de ingresar esto a Git Bash, ¡te pedirá una frase de contraseña!

¡Tenga en cuenta que la clave privada de openssh y la clave privada de masilla son diferentes!

Si ha creado sus claves con puttygen, ¡debe convertir su clave privada a openssh!

Podría usar la variable de entorno GIT_SSH. Pero deberá envolver ssh y opciones en un script de shell.

Vea el manual de git: man giten su shell de comandos.

Utilizo zshy las claves diferentes se cargan en mi shell zsh ssh-agentautomáticamente para otros fines (es decir, acceso a servidores remotos) en mi computadora portátil. Modifiqué la respuesta de @ Nick y la estoy usando para uno de mis repositorios que necesita actualizarse a menudo. (En este caso, es el dotfilesque quiero y la misma versión más reciente en todas mis máquinas, donde sea que esté trabajando).

bash -c 'eval `ssh-agent`; ssh-add /home/myname/.dotfiles/gitread; ssh-add -L; cd /home/myname/.dotfiles && git pull; kill $SSH_AGENT_PID'

• Engendrar un agente ssh
• Agregar clave de solo lectura al agente
• Cambiar directorio a mi repositorio git
• Si cd directorio de repositorio tiene éxito, extraiga del repositorio remoto
• Mata al agente ssh engendrado. (No quisiera que muchos agentes permanecieran por ahí).

para el gitlab RSAAuthentication yes

Host gitlab.com
  RSAAuthentication yes
  IdentityFile ~/.ssh/your_private_key_name
  IdentitiesOnly yes

el documento está aquí

Para que la variable de entorno GIT_SSH_COMMAND funcione en Windows en lugar de:

set GIT_SSH_COMMAND="ssh -i private_key_file"

Utilizar:

set "GIT_SSH_COMMAND=ssh -i private_key_file"

La cita tiene que ser como

set "variable=value" 

Algunos antecedentes: https://stackoverflow.com/a/34402887/10671021

Si el número de puerto SSH no es 22 (por defecto), añadir Port xxen~/.ssh/config

En mi caso (sinología),

Host my_synology
    Hostname xxxx.synology.me
    IdentityFile ~/.ssh/id_rsa_xxxx
    User myname
    Port xx

Luego clone usando el título del Host en la configuración. ("my_synology". para evitar @chopstik 's "*")

git clone my_synology:path/to/repo.git

Si eres como yo, puedes:

• Mantenga sus claves ssh organizadas

• Mantenga sus comandos git clone simples

• Maneje cualquier cantidad de claves para cualquier cantidad de repositorios.

• Reduzca el mantenimiento de su clave ssh.

Guardo mis llaves en mi ~/.ssh/keys directorio.

Prefiero la convención sobre la configuración.

Creo que el código es ley; cuanto más simple sea, mejor.

PASO 1 - Crear alias

Agregue este alias a su shell: alias git-clone='GIT_SSH=ssh_wrapper git clone'

PASO 2 - Crear secuencia de comandos

Agregue este script ssh_wrapper a su RUTA:

#!/bin/bash
# Filename: ssh_wrapper

if [ -z ${SSH_KEY} ]; then
    SSH_KEY='github.com/l3x'  # <= Default key
fi
SSH_KEY="~/.ssh/keys/${SSH_KEY}/id_rsa"
ssh -i "${SSH_KEY}" "$@"

EJEMPLOS

Use la clave github.com/l3x:

KEY=github.com/l3x git-clone https://github.com/l3x/learn-fp-go

El siguiente ejemplo también usa la clave github.com/l3x (por defecto):

git-clone https://github.com/l3x/learn-fp-go

Use la clave bitbucket.org/lsheehan:

KEY=bitbucket.org/lsheehan git-clone git@bitbucket.org:dave_andersen/exchange.git

NOTAS

Cambie el SSH_KEY predeterminado en el script ssh_wrapper a lo que usa la mayor parte del tiempo. De esa manera, no necesita usar la variable KEY la mayor parte del tiempo.

Puede pensar: "¡Oye! Eso está sucediendo con un alias, un script y un directorio de teclas", pero para mí es una convención. Casi todas mis estaciones de trabajo (y servidores para el caso) están configuradas de manera similar.

Mi objetivo aquí es simplificar los comandos que ejecuto regularmente.

Mis convenciones, por ejemplo, secuencias de comandos Bash, alias, etc., crean un entorno coherente y me ayudan a simplificar las cosas.

El beso y los nombres importan.

Para obtener más consejos de diseño, consulte el Capítulo 4 Diseño SÓLIDO en Ir de mi libro: https://www.amazon.com/Learning-Functional-Programming-Lex-Sheehan-ebook/dp/B0725B8MYW

Espero que ayude. - Lex

Puede probar el paquete sshmulti npm para mantener varias claves ssh.

El problema con este método es, al menos cuando se ejecuta bash.exe en Windows, que creará un nuevo proceso cada vez que permanecerá inactivo.

ssh-agent bash -c 'ssh-add /somewhere/yourkey; git clone git@github.com:user/project.git'

Si desea usar eso para sincronizar el repositorio según lo programado, entonces debe agregar "&& ssh-agent -k" al final.

Algo como:

ssh-agent bash -c 'ssh-add C:/Users/user/.ssh/your_key; git -C "C:\Path\to\your\repo" pull && ssh-agent -k' 

ssh-agent -k matará el proceso cuando esté hecho.

Solo necesitaba agregar la clave y luego ejecutar el clon git nuevamente.

ssh-add ~/.ssh/id_rsa_mynewkey
git clone git@bitbucket.org:mycompany/myrepo.git

Aquí está el truco de la clave ssh que encontré al encontrar una solución a este problema:

Por ejemplo, tiene 2 juegos de llaves diferentes:

key1, key1.pub, key2, key2.pub

Mantenga estas claves en su .sshdirectorio

Ahora en su archivo .bashrco .bash_profilealias, agregue estos comandos

alias key1='cp ~/.ssh/key1 id_rsa && cp ~/.ssh/key1.pub id_rsa.pub'

alias key2='cp ~/.ssh/key2 id_rsa && cp ~/.ssh/key2.pub id_rsa.pub'

Voila! ¡Tienes un atajo para cambiar las teclas cuando quieras!

Espero que esto funcione para usted.