Desejo usar várias chaves privadas para conectar-me a diferentes servidores ou partes diferentes do mesmo servidor (meus usos são administração do sistema do servidor, administração do Git e uso normal do Git no mesmo servidor). Tentei simplesmente empilhar as chaves nos id_rsaarquivos sem sucesso.

Aparentemente, uma maneira direta de fazer isso é usar o comando

ssh -i <key location> login@server.example.com 

Isso é bastante complicado.

Alguma sugestão de como fazer isso um pouco mais fácil?

Do meu .ssh/config:

Host myshortname realname.example.com
    HostName realname.example.com
    IdentityFile ~/.ssh/realname_rsa # private key for realname
    User remoteusername

Host myother realname2.example.org
    HostName realname2.example.org
    IdentityFile ~/.ssh/realname2_rsa  # different private key for realname2
    User remoteusername

E assim por diante.

Você pode instruir o ssh a tentar várias chaves sucessivamente ao se conectar. Aqui está como:

$ cat ~/.ssh/config
IdentityFile ~/.ssh/id_rsa
IdentityFile ~/.ssh/id_rsa_old
IdentityFile ~/.ssh/id_ed25519
# ... and so on

$ ssh server.example.com -v
....
debug1: Next authentication method: publickey
debug1: Trying private key: /home/example/.ssh/id_rsa
debug1: read PEM private key done: type RSA
debug1: Authentications that can continue: publickey
debug1: Trying private key: /home/example/.ssh/id_rsa_old
debug1: read PEM private key done: type RSA
....
[server ~]$

Dessa forma, você não precisa especificar qual chave funciona com qual servidor. Apenas usará a primeira chave de trabalho.

Além disso, você só digitaria uma senha se um determinado servidor estiver disposto a aceitar a chave. Como visto acima, o ssh não tentou solicitar uma senha, .ssh/id_rsamesmo que tivesse uma.

Certamente não supera uma configuração por servidor como em outras respostas, mas pelo menos você não precisará adicionar uma configuração para todo e qualquer servidor ao qual você se conecta!

A resposta de Randal Schwartz quase me ajudou por todo o caminho. Eu tenho um nome de usuário diferente no servidor, então tive que adicionar a palavra-chave Usuário ao meu arquivo:

Host           friendly-name
HostName       long.and.cumbersome.server.name
IdentityFile   ~/.ssh/private_ssh_file
User           username-on-remote-machine

Agora você pode se conectar usando o nome amigável:

ssh friendly-name

Mais palavras-chave podem ser encontradas na página do manual OpenSSH . NOTA: Algumas das palavras-chave listadas podem já estar presentes no seu arquivo / etc / ssh / ssh_config .

As respostas anteriores explicaram adequadamente a maneira de criar um arquivo de configuração para gerenciar várias chaves ssh. Penso que o importante que também precisa ser explicado é a substituição de um nome de host por um nome alternativo ao clonar o repositório .

Suponha que o nome de usuário da sua conta GitHub seja abc1234 . E suponha que o nome de usuário da sua conta pessoal do GitHub seja jack1234

E suponha que você tenha criado duas chaves RSA, ou seja, id_rsa_company e id_rsa_personal . Portanto, seu arquivo de configuração será semelhante a seguir:

# Company account
Host company
HostName github.com
PreferredAuthentications publickey
IdentityFile ~/.ssh/id_rsa_company

# Personal account
Host personal
HostName github.com
PreferredAuthentications publickey
IdentityFile ~/.ssh/id_rsa_personal

Agora, quando você estiver clonando o repositório (chamado demo) da conta GitHub da empresa, a URL do repositório será algo como:

Repo URL: git@github.com:abc1234/demo.git

Agora, enquanto estiver fazendo git clone, você deve modificar a URL do repositório acima como:

git@company:abc1234/demo.git

Observe como o github.com agora é substituído pelo alias "company", conforme definido no arquivo de configuração.

Da mesma forma, você deve modificar o URL do clone do repositório na conta pessoal, dependendo do alias fornecido no arquivo de configuração.

ssh-add ~/.ssh/xxx_id_rsa

Teste-o antes de adicionar com:

ssh -i ~/.ssh/xxx_id_rsa username@example.com

Se você tiver algum problema com erros, às vezes, alterar a segurança do arquivo ajuda:

chmod 0600 ~/.ssh/xxx_id_rsa

1. Gere uma chave SSH:

   $ ssh-keygen -t rsa -C <email1@example.com>
   

2. Gere outra chave SSH :

   $ ssh-keygen -t rsa -f ~/.ssh/accountB -C <email2@example.com>
   

   Agora, duas chaves públicas ( id_rsa.pub , accountB.pub ) devem existir no ~/.ssh/diretório

   $ ls -l ~/.ssh     # see the files of '~/.ssh/' directory
   

3. Crie um arquivo de configuração ~/.ssh/configcom o seguinte conteúdo:

   $ nano ~/.ssh/config
   
   Host bitbucket.org
       User git
       Hostname bitbucket.org
       PreferredAuthentications publickey
       IdentityFile ~/.ssh/id_rsa
   
   Host bitbucket-accountB
       User git
       Hostname bitbucket.org
       PreferredAuthentications publickey
       IdentitiesOnly yes
       IdentityFile ~/.ssh/accountB
   

4. Clone da defaultconta.

   $ git clone git@bitbucket.org:username/project.git
   

5. Clone da accountBconta.

   $ git clone git@bitbucket-accountB:username/project.git
   

Veja mais aqui

Eu concordo com Tuomas sobre o uso do ssh-agent. Eu também queria adicionar uma segunda chave privada para o trabalho e este tutorial funcionou como um encanto para mim.

Os passos são os seguintes:

1. $ ssh-agent bash
2. $ ssh-add /path.to/private/key por exemplo ssh-add ~/.ssh/id_rsa
3. Verificar por $ ssh-add -l
4. Testá-lo com $ssh -v <host url>egssh -v git@assembla.com

Eu já havia enfrentado esse problema há algum tempo, quando tinha duas contas Bitbucket e queria armazenar chaves SSH separadas para ambas. Isto é o que funcionou para mim.

Criei duas configurações ssh separadas da seguinte maneira.

Host personal.bitbucket.org
    HostName bitbucket.org
    User git
    IdentityFile /Users/username/.ssh/personal
Host work.bitbucket.org
    HostName bitbucket.org
    User git
    IdentityFile /Users/username/.ssh/work

Agora, quando eu tive que clonar um repositório da minha conta de trabalho - o comando foi o seguinte.

git clone git@bitbucket.org:teamname/project.git

Eu tive que modificar este comando para:

git clone git@**work**.bitbucket.org:teamname/project.git

Da mesma forma, o comando clone da minha conta pessoal teve que ser modificado para

git clone git @ pessoal .bitbucket.org: name / personalproject.git

Consulte este link para obter mais informações.

Use ssh-agent para suas chaves.

Agora, com a versão recente do Git, podemos especificar sshCommand no arquivo de configuração Git específico do repositório:

  [core]
      repositoryformatversion = 0
      filemode = true
      bare = false
      logallrefupdates = true
      sshCommand = ssh -i ~/.ssh/id_rsa_user
   [remote "origin"]
      url = git@bitbucket.org:user/repo.git
      fetch = +refs/heads/*:refs/remotes/origin/*

Você pode criar um arquivo de configuração nomeado configem sua ~/.sshpasta. Pode conter:

Host aws
    HostName *yourip*
    User *youruser*
    IdentityFile *idFile*

Isso permitirá que você se conecte a máquinas como esta

 ssh aws

IMPORTANTE: Você deve iniciar o ssh-agent

Você deve iniciar o ssh-agent (se já não estiver em execução) antes de usar o ssh-add da seguinte maneira:

eval `ssh-agent -s` # start the agent

ssh-add id_rsa_2 # Where id_rsa_2 is your new private key file

Observe que o comando eval inicia o agente no Git Bash no Windows. Outros ambientes podem usar uma variante para iniciar o agente SSH.

No Ubuntu 18.04 (Bionic Beaver) não há nada para fazer.

Depois de criar com êxito uma segunda chave SSH, o sistema tentará encontrar uma chave SSH correspondente para cada conexão.

Só para esclarecer, você pode criar uma nova chave com estes comandos:

# Generate key make sure you give it a new name (id_rsa_server2)
ssh-keygen

# Make sure ssh agent is running
eval `ssh-agent`

# Add the new key
ssh-add ~/.ssh/id_rsa_server2

# Get the public key to add it to a remote system for authentication
cat ~/.ssh/id_rsa_server2.pub

Vários pares de chaves no GitHub

1.0 arquivo de configuração SSH

1.1 Criar ~ / .ssh / config

1.2 chmod 600 ~ / .ssh / config ( obrigatório )

1.3 Insira o seguinte no arquivo:

Hospedar pizza

HostName github.com

PreferredAuthentications publickey # optional

IdentityFile ~ / .ssh / privatekey1

Caso A: novo clone do Git

Use este comando para clonar Git:

$ git clone git@pizza:yourgitusername/pizzahut_repo.git

Nota: Se desejar alterar o nome do host “pizza” de .ssh / config no futuro, vá para a pasta clonada Git, edite a linha de URL do arquivo .git / config (consulte o caso B)

Caso B: já tem pasta clone do Git

2.1 Vá para a pasta clonada e, em seguida, vá para a pasta .git

2.2 Editar arquivo de configuração

2.3 Atualize o URL de * antigo para novo :

(Old) URL = git@github.com:yourgitusername/pizzahut_repo.git

(New) URL = git@pizza:yourgitusername/pizzahut_repo.git

Para mim, a única solução de trabalho era simplesmente adicionar isso no arquivo ~/.ssh/config:

Host *
  IdentityFile ~/.ssh/your_ssh_key
  IdentityFile ~/.ssh/your_ssh_key2
  IdentityFile ~/.ssh/your_ssh_key3
  AddKeysToAgent yes

your_ssh_keyestá sem nenhuma extensão. Não use .pub.

No CentOS 6.5 executando o OpenSSH_5.3p1 e o OpenSSL 1.0.1e-fips, resolvi o problema renomeando meus arquivos-chave para que nenhum deles tivesse o nome padrão.

Meu diretório .ssh contém id_rsa_foo e id_rsa_bar, mas não id_rsa, etc.

Conforme mencionado em uma página de blog Atlassian , gere um arquivo de configuração dentro da pasta .ssh , incluindo o seguinte texto:

#user1 account
 Host bitbucket.org-user1
     HostName bitbucket.org
     User git
     IdentityFile ~/.ssh/user1
     IdentitiesOnly yes

 #user2 account
 Host bitbucket.org-user2
     HostName bitbucket.org
     User git
     IdentityFile ~/.ssh/user2
     IdentitiesOnly yes

Em seguida, você pode simplesmente fazer o checkout com o domínio do sufixo e, nos projetos, você pode configurar os nomes dos autores, etc. localmente.

Aqui está a solução que usei inspirada na resposta de sajib-khan . A configuração padrão não está definida; é minha conta pessoal no GitLab e a outra especificada é minha conta corporativa . Aqui está o que eu fiz:

Gere a chave SSH

ssh-keygen -t rsa -f ~/.ssh/company -C "name.surname@company.com"

Edite a configuração SSH

nano ~/.ssh/config

    Host company.gitlab.com
    HostName gitlab.com
    PreferredAuthentications publickey
    IdentityFile ~/.ssh/company

Exclua as chaves SSH em cache

ssh-add -D

Teste-o!

ssh -T git@company.gitlab.com

Bem-vindo ao GitLab, @ hugo.sohm!

ssh -T git@gitlab.com

Bem-vindo ao GitLab, @HugoSohm!

Use-o!

Conta da empresa

git clone git@company.gitlab.com:group/project.git

Conta pessoal / padrão

git clone git@gitlab.com:username/project.git

Aqui está a fonte que eu usei.

Eu amo a abordagem para definir o seguinte no arquivo ~ / .ssh / config:

# Configuration for GitHub to support multiple GitHub  keys
Host  github.com
  HostName github.com
  User git

# UseKeychain adds each keys passphrase to the keychain so you
# don't have to enter the passphrase each time.
  UseKeychain yes

# AddKeysToAgent would add the key to the agent whenever it is
# used, which might lead to debugging confusion since then
# sometimes the one repository works and sometimes the
# other depending on which key is used first.
#  AddKeysToAgent yes

# I only use my private id file so all private
# repositories don't need the environment variable
# `GIT_SSH_COMMAND="ssh -i ~/.ssh/id_rsa"` to be set.
  IdentityFile ~/.ssh/id_rsa

Em seu repositório, você pode criar um .envarquivo que contenha o sshcomando a ser usado:

GIT_SSH_COMMAND="ssh -i ~/.ssh/your_ssh_key"

Se você usar, por exemplo, dotenv a variável de ambiente do ambiente será exportada automaticamente e , você poderá especificar a chave que deseja por projeto / diretório. A senha é solicitada apenas uma vez, pois é adicionada ao chaveiro.

Esta solução funciona perfeitamente com o Git e foi projetada para funcionar em um Mac (devido a UseKeychain).

Você pode experimentar este pacote sshmulti npm para manter várias chaves SSH.