tutorial - Como especificar a chave SSH privada para usar ao executar o comando shell no Git?




ssh tutorial github (14)

Uma situação bastante incomum, talvez, mas eu quero especificar uma chave SSH privada para usar ao executar um comando shell (git) a partir do computador local.

Basicamente assim:

git clone [email protected].com:TheUser/TheProject.git -key "/home/christoffer/ssh_keys/theuser"

Ou melhor ainda (em Ruby):

with_key("/home/christoffer/ssh_keys/theuser") do
  sh("git clone [email protected]:TheUser/TheProject.git")
end

Eu vi exemplos de conexão a um servidor remoto com Net :: SSH que usa uma chave privada especificada, mas este é um comando local. É possível?


A partir do Git 2.3.0 também temos o comando simples (não é necessário nenhum arquivo de configuração):

GIT_SSH_COMMAND='ssh -i private_key_file' git clone [email protected]:repo.git

Você pode precisar de uma reinicialização para o serviço ssh em sua máquina.


Algo como isso deve funcionar (sugerido por orip):

ssh-agent bash -c 'ssh-add /somewhere/yourkey; git clone [email protected]:user/project.git'

Se você preferir subshells, você pode tentar o seguinte (embora seja mais frágil):

ssh-agent $(ssh-add /somewhere/yourkey; git clone [email protected].com:user/project.git)

O Git invocará o SSH que encontrará seu agente pela variável de ambiente; isso, por sua vez, terá a chave carregada.

Como alternativa, a configuração HOME também pode funcionar, desde que você esteja disposto a configurar um diretório que contenha apenas um diretório .ssh como HOME ; isso pode conter um identity.pub ou um arquivo de configuração definindo IdentityFile.


Com git 2.10+ (T3 2016: lançado em 2 de setembro de 2016), você tem a possibilidade de definir uma configuração para GIT_SSH_COMMAND (e não apenas uma variável de ambiente como descrito na answer )

Veja commit 3c8ede3 (26 Jun 2016) de Nguyễn Thái Ngọc Duy ( pclouds ) .
(Mesclado por Junio ​​C Hamano - gitster - em commit dc21164 , 19 de julho de 2016)

Uma nova variável de configuração core.sshCommand foi incluída para especificar qual valor para GIT_SSH_COMMAND usar por repositório.

core.sshCommand:

Se esta variável for configurada, git fetch e git push usarão o comando especificado em vez de ssh quando precisarem se conectar a um sistema remoto.
O comando está na mesma forma que a variável de ambiente GIT_SSH_COMMAND e é sobrescrito quando a variável de ambiente é configurada.

Isso significa que o git clone pode ser:

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


Eu fui com a variável de ambiente GIT_SSH. Aqui está o meu wrapper, semelhante ao do Joe Block acima, mas lida com qualquer quantidade de argumentos.

Arquivo ~ / gitwrap.sh

#!/bin/bash
ssh -i ~/.ssh/gitkey_rsa "[email protected]"

Então, no meu .bashrc, adicione o seguinte:

export GIT_SSH=~/gitwrap.sh

Eu uso o zsh e chaves diferentes são carregadas para o ssh-agent do meu shell zsh automaticamente para outros propósitos (por exemplo, acesso a servidores remotos) no meu laptop. Eu modifiquei a resposta do @ Nick e estou usando para um dos meus repositórios que precisam ser atualizados com frequência. (Neste caso são meus dotfiles que eu quero a versão igual e mais recente em todas as minhas máquinas, onde quer que eu esteja trabalhando.)

bash -c 'eval `ssh-agent`; ssh-add /home/myname/.dotfiles/gitread; ssh-add -L; cd /home/myname/.dotfiles && git pull; kill $SSH_AGENT_PID'
  • Gerar um agente ssh
  • Adicionar chave somente leitura ao agente
  • Alterar o diretório para o meu repositório git
  • Se cd para repo dir for bem sucedido, puxe de repo remoto
  • Matar spawned ssh-agent. (Eu não gostaria que muitos agentes permanecessem por perto.)

Muitas dessas soluções pareciam atraentes. No entanto, achei que a abordagem genérica de quebra de script-git no link a seguir é a mais útil:

Como especificar um arquivo de chave ssh com o comando git

O ponto é que não existe um comando git como o seguinte:

git -i ~/.ssh/thatuserkey.pem clone [email protected].com:/git/repo.git

A solução de Alvin é usar um script de wrapper bem definido que preenche essa lacuna:

git.sh -i ~/.ssh/thatuserkey.pem clone [email protected].com:/git/repo.git

Onde git.sh é:

#!/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 \[email protected]" > /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 "[email protected]"

Posso verificar que isso resolveu um problema que eu estava tendo com o reconhecimento de chave / usuário para um repositório bitbucket remoto com git remote update , git pull e git clone ; todos os quais agora funcionam bem em um script de tarefa cron que estava tendo problemas para navegar pelo shell limitado. Eu também era capaz de chamar este script de dentro de R e ainda resolver exatamente o mesmo problema de execução do cron (por exemplo, system("bash git.sh -i ~/.ssh/thatuserkey.pem pull") ).

Não que R seja o mesmo que Ruby, mas se R puder fazer isso ... O :-)


Nenhuma dessas soluções funcionou para mim.

Em vez disso, eu elaborei sobre a menção do @Martin v. Löwis de configurar um arquivo de config para o SSH.

O SSH procurará pelo arquivo ~/.ssh/config do usuário. Eu tenho minha configuração como:

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

E eu adiciono um repositório git remoto:

git remote add origin [email protected]:myrepo.git

E então os comandos do git funcionam normalmente para mim.

git push -v origin master

NOTAS

  • O IdentitiesOnly yes é necessário para impedir o comportamento padrão do SSH de enviar o arquivo de identidade correspondente ao nome de arquivo padrão para cada protocolo. Se você tem um arquivo chamado ~/.ssh/id_rsa que será tentado ANTES de seu ~/.ssh/id_rsa.github sem esta opção.

Referências



Para resumir as respostas e comments , a melhor maneira de configurar o git para usar diferentes arquivos de chave e depois esquecê-lo, que também suporta diferentes usuários para o mesmo host (por exemplo, uma conta pessoal do GitHub e uma de trabalho), que funciona no Windows também, é editar ~/.ssh/config (ou c:\Users\<your user>\.ssh\config ) e especificar múltiplas 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

Então, para clonar um projeto como seu usuário pessoal, basta executar o comando regular git clone .

Para clonar o workuser como o workuser , execute git clone [email protected]:company/project.git .


Se nenhuma das outras soluções aqui funciona para você, e você criou várias chaves ssh, mas ainda não pode fazer coisas simples como

git pull

em seguida, assumindo que você tem dois arquivos-chave ssh como

id_rsa
id_rsa_other_key

então dentro do repositório do git com o qual você está lutando (cd para lá), tente:

ssh-add ~/.ssh/id_rsa
ssh-add ~/.ssh/id_rsa_other_key

e também certifique-se de que seu nome de usuário e ID do usuário do github estão corretos por:

git config user.name "Mona Lisa"
git config user.email "[email protected]"

Veja gist.github.com/jexchan/2351996 para mais informações.


Se o número da porta SSH não for 22 (padrão), adicione a Port xx em ~/.ssh/config

No meu caso (sinologia),

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

Em seguida, clone usando o título do host na configuração. ("my_synology". para evitar o "*" de @chopstik)

git clone my_synology:path/to/repo.git

Você poderia usar a variável de ambiente GIT_SSH. Mas você precisará colocar o ssh e as opções em um script de shell.

Veja git manual: man git no seu shell de comando.


Você precisa criar um ~ / .ssh / config como abaixo

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

permissão como abaixo

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

Adicione sua chave pública em seu git (cat ~ / .ssh / id_rsa_pub [or simillar name])

e então git clone como abaixo

git clone ssh://[email protected].com/userid/test.git




ssh