sshtem a -iopção de informar qual arquivo de chave privada usar ao autenticar:

-i identity_file

Seleciona um arquivo a partir do qual a identidade (chave privada) para autenticação RSA ou DSA é lida. O padrão é ~/.ssh/identitypara a versão 1 do protocolo ~/.ssh/id_rsae ~/.ssh/id_dsapara a versão 2. do protocolo. Os arquivos de identidade também podem ser especificados por host no arquivo de configuração. É possível ter várias -iopções (e várias identidades especificadas nos arquivos de configuração).

Existe uma maneira semelhante de saber gitqual arquivo de chave privada usar em um sistema com várias chaves privadas no ~/.sshdiretório?

Em ~/.ssh/config, adicione:

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

Agora você pode fazer git clone git@github.com:username/repo.git.

NOTA: Verifique se as permissões no IdentityFile são 400. O SSH rejeitará, de maneira não claramente explícita, as chaves SSH que são legíveis demais. Será apenas uma rejeição de credencial. A solução, neste caso, é:

chmod 400 ~/.ssh/id_rsa_github

Variável de ambiente GIT_SSH_COMMAND:

No Git versão 2.3.0, você pode usar a variável de ambiente GIT_SSH_COMMANDassim:

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

Observe que -iàs vezes pode ser substituído pelo seu arquivo de configuração; nesse caso, você deve fornecer ao SSH um arquivo de configuração vazio, como este:

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

Configuração core.sshCommand:

Na versão 2.10.0 do Git, você pode configurar isso por repo ou globalmente, para não precisar mais definir a variável de ambiente!

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

Não há uma maneira direta de saber gitqual chave privada usar, porque ela depende sshda autenticação do repositório. No entanto, ainda existem algumas maneiras de atingir seu objetivo:

Opção 1: ssh-agent

Você pode usar ssh-agentpara autorizar temporariamente sua chave privada.

Por exemplo:

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

Opção 2: GIT_SSH_COMMAND

Passe os argumentos ssh usando a GIT_SSH_COMMANDvariável de ambiente (Git 2.3.0+).

Por exemplo:

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

_{Você pode digitar tudo isso em uma linha - ignore $e deixe de fora o \.}

Opção 3: GIT_SSH

Passe os argumentos ssh usando a GIT_SSHvariável de ambiente para especificar o sshbinário alternativo .

Por exemplo:

$ 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: As linhas acima são linhas de comando shell (terminal) que você deve colar no seu terminal. Eles criarão um arquivo chamado ssh, o tornarão executável e (indiretamente) o executarão.}

^{Nota: GIT_SSHestá disponível desde a v0.99.4 (2005).}

Opção 4: ~/.ssh/config

Use o ~/.ssh/configarquivo conforme sugerido em outras respostas para especificar o local da sua chave privada, por exemplo

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

Escreva um script que chame sshcom os argumentos desejados e insira o nome do arquivo do script $GIT_SSH. Ou apenas coloque sua configuração ~/.ssh/config.

Se você não deseja especificar variáveis ​​de ambiente sempre que executar o git, não deseja outro script de wrapper, não pode / não pode executar o ssh-agent (1) nem deseja fazer o download de outro pacote apenas para isso, use o 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 esta solução superior porque:

• É específico do repositório / remoto
• Evite o inchaço do script do wrapper
• Não precisa do agente SSH - útil se você quiser clones / push / pull autônomos (por exemplo, no cron)
• Definitivamente, nenhuma ferramenta externa é necessária

Use a configuração personalizada do host ~/.ssh/config, desta forma:

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

use seu nome de host personalizado assim:

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

Depois da minha luta, $GIT_SSHeu gostaria de compartilhar o que funcionou para mim.

Pelos meus exemplos, assumirei que você tem sua chave privada localizada em/home/user/.ssh/jenkins

Erro a evitar: o valor GIT_SSH inclui opções

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

ou qualquer falha semelhante, pois o git tentará executar o valor como um arquivo . Por esse motivo, você deve criar um script.

Exemplo de trabalho do script $ GIT_SSH /home/user/gssh.sh

O script será chamado da seguinte maneira:

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

Um exemplo de trabalho de script pode ter a seguinte aparência:

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

Observe o $*no final, é parte importante disso.

Uma alternativa ainda mais segura, que impediria qualquer possível conflito com qualquer coisa no seu arquivo de configuração padrão (além de mencionar explicitamente a porta a ser usada) seria:

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

Assumindo que o script esteja /home/user/gssh.sh, você deve:

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

e tudo deve funcionar.

Você pode apenas usar ssh-ident em vez de criar seu próprio wrapper.

Você pode ler mais em: https://github.com/ccontavalli/ssh-ident

Carrega chaves ssh sob demanda quando necessário, uma vez, mesmo com várias sessões de login, xterms ou casas compartilhadas NFS.

Com um pequeno arquivo de configuração, ele pode carregar automaticamente chaves diferentes e mantê-las separadas em agentes diferentes (para encaminhamento de agente), dependendo do que você precisa fazer.

Eu tinha um cliente que precisava de uma conta separada no github. Então, eu precisava usar uma chave separada apenas para este projeto.

Minha solução foi adicionar isso ao meu .zshrc / .bashrc:

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

Sempre que eu quero usar o git para esse projeto, substituo "infogit" por git:

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

Para mim, é mais fácil lembrar.

Então, defino a variável env GIT_SSH como $HOME/bin/git-ssh.

Para que a minha configuração de repositório determine que identidade ssh usar, meu ~/bin/git-ssharquivo é o seguinte:

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

Então eu tenho uma configuração global de configuração do git:

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

E dentro de qualquer repositório git, posso apenas definir um ssh.identityvalor de configuração local do git:

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

Voila!

Se você pode ter um endereço de email diferente para cada identidade, fica ainda mais simples, porque você pode apenas nomear suas chaves após seus endereços de email e solicitar ao user.e do git config. Email conduz a seleção de chaves da ~/bin/git-sshseguinte maneira:

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

Minha solução foi esta:

crie um 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

quando você precisar alterar a execução var:

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

Não esqueça o ponto extra !! isso faz o script definir os ambientes variados !! --key e --port são opcionais.

Geralmente, você deseja usar ~/.ssh/configpara isso. Simplesmente emparelhe os endereços do servidor com as chaves que você deseja usar para eles da seguinte maneira:

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

Host *denota qualquer servidor, então eu o uso para definir ~/.ssh/id_rsacomo a chave padrão a ser usada.

Eu desenvolvo o @shellholic e esse tópico SO com algumas dicas. Eu uso o GitHub como exemplo e suponho que você tenha uma chave privada ~/.ssh/github(caso contrário, consulte este tópico do SO ) e que você adicionou a chave pública ao seu perfil do GitHub (caso contrário, consulte a ajuda do GitHub ).

Se necessário, crie um novo arquivo de configuração SSH em ~/.ssh/confige altere as permissões para 400

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

Adicione isso ao ~/.ssh/configarquivo:

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

Se você já possui uma configuração remota, convém excluí-la, caso contrário, você ainda poderá solicitar o nome de usuário e a senha:

git remote rm origin

Em seguida, adicione um controle remoto ao repositório git e observe os dois pontos antes do nome do usuário:

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

E então os comandos git funcionam normalmente, por exemplo:

git push origin master
git pull origin 

@HeyWatchThis neste encadeamento SO sugeriu a adição IdentitiesOnly yespara impedir o comportamento padrão do SSH de enviar o arquivo de identidade correspondente ao nome do arquivo padrão para cada protocolo. Veja esse tópico para mais informações e referências.

Basta usar ssh-agente 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>

Depois de executar os comandos acima, você pode usar as duas teclas ao mesmo tempo. Apenas digite

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

clonar seu repositório.

Você precisa executar o comando acima depois de reiniciar sua máquina.

Estou usando o git versão 2.16 e não preciso de um único pedaço de script, nem mesmo de um comando config ou modificado.

• Apenas copiei minha chave privada para .ssh / id_rsa
• definir permissões para 600

E o git lê a chave automaticamente. Eu não pergunto nada e não gera um erro. Apenas funciona bem.

Embora a pergunta não solicite, estou incluindo esta resposta para qualquer pessoa que esteja procurando resolver o mesmo problema especificamente para o gitlab .

A solução gitlab

Tentei usar a abordagem de variáveis ​​de ambiente , mas mesmo a documentação do git recomenda usar ~/.ssh/configalgo além do simples caso. No meu caso, estou enviando para um servidor gitlab - e queria fazê-lo como um usuário específico - que é definido pela chave privada durante a autenticação e não pelo nome de usuário git. Uma vez implementado, basta executar o seguinte:

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

Configuração

Lembre-se da localização da sua chave privada /myfolder/.ssh/my_gitlab_id_rsa no meu caso.

Adicione uma entrada em ~/.ssh/config:

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

Adicione o git-alias em ~/.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 bônus, eu realizo meus commits neste mesmo host que um usuário específico com este git-alias :

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

Explicação

Todas as opções acima assumem que o controle remoto é originrelevante e que o ramo relevante está atualmente com check-out. Para referência, encontrei vários itens que precisavam ser abordados:

• A solução requer a criação de um novo controle remoto gitlab_as_me, e eu não gostei de ver o controle remoto extra pendurado na minha árvore de logs, então removo-o quando terminar
• Para criar o controle remoto, é necessário gerar a URL do controle em tempo real - no caso do gitlab, isso foi alcançado com um corte simples do bash
• Ao executar um push, gitlab_as_mevocê precisa ser específico sobre qual ramo você está empurrando
• Depois de executar o push, seu originponteiro local precisa ser "atualizado" para corresponder gitlab_as_me(o que git pull origin $branchfaz isso)

Quando você tem várias contas git e deseja uma chave ssh diferente

Você deve seguir o mesmo passo para gerar a chave ssh, mas não se esqueça de

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

Digite o caminho que você deseja salvar (por exemplo: my-pc / Desktop / .ssh / ed25519)

Adicione a chave pública ao seu gitlab ( Como adicionar a chave ssh ao gitlab )

Você precisa da nova identidade ssh usando o comando abaixo

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

    # 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