Voglio usare più chiavi private per connettermi a server diversi o porzioni diverse dello stesso server (i miei usi sono l'amministrazione del sistema del server, l'amministrazione di Git e il normale utilizzo di Git all'interno dello stesso server). Ho provato semplicemente ad impilare le chiavi nei id_rsafile senza risultati.

Apparentemente un modo semplice per farlo è usare il comando

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

È piuttosto ingombrante.

Qualche suggerimento su come procedere un po 'più facilmente?

Dal mio .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 così via.

È possibile indicare a ssh di provare più chiavi in ​​successione durante la connessione. Ecco come:

$ 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 ~]$

In questo modo non è necessario specificare quale chiave funziona con quale server. Userà solo la prima chiave di lavoro.

Inoltre, inserire una passphrase solo se un determinato server è disposto ad accettare la chiave. Come visto sopra, ssh non ha provato a chiedere una password .ssh/id_rsaanche se ne aveva una.

Sicuramente non supera una configurazione per server come in altre risposte, ma almeno non dovrai aggiungere una configurazione per tutti i server a cui ti connetti!

La risposta di Randal Schwartz mi ha quasi aiutato fino in fondo. Ho un nome utente diverso sul server, quindi ho dovuto aggiungere la parola chiave User al mio file:

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

Ora puoi connetterti usando il nome descrittivo:

ssh friendly-name

Altre parole chiave sono disponibili nella pagina man di OpenSSH . NOTA: alcune delle parole chiave elencate potrebbero essere già presenti nel file / etc / ssh / ssh_config .

Le risposte precedenti hanno spiegato correttamente il modo di creare un file di configurazione per gestire più chiavi SSH. Penso che la cosa importante che deve anche essere spiegata è la sostituzione di un nome host con un nome alias durante la clonazione del repository .

Supponiamo che il nome utente dell'account GitHub della tua azienda sia abc1234 . Supponiamo che il nome utente del tuo account GitHub personale sia jack1234

Supponiamo di aver creato due chiavi RSA, vale a dire id_rsa_company e id_rsa_personal . Quindi, il tuo file di configurazione apparirà come di seguito:

# 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

Ora, quando clonate il repository (chiamato demo) dall'account GitHub dell'azienda, l'URL del repository sarà simile a:

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

Ora, mentre lo fai git clone, dovresti modificare l'URL del repository sopra come:

git@company:abc1234/demo.git

Notare come github.com è ora sostituito con l'alias "company" come abbiamo definito nel file di configurazione.

Allo stesso modo, è necessario modificare l'URL del clone del repository nell'account personale in base all'alias fornito nel file di configurazione.

ssh-add ~/.ssh/xxx_id_rsa

Assicurati di provarlo prima di aggiungere con:

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

In caso di problemi con errori, a volte la modifica della sicurezza del file aiuta:

chmod 0600 ~/.ssh/xxx_id_rsa

1. Genera una chiave SSH:

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

2. Genera un'altra chiave SSH :

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

   Ora, due directory pubbliche ( id_rsa.pub , accountB.pub ) dovrebbero essere presenti nella ~/.ssh/directory.

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

3. Creare il file di configurazione ~/.ssh/configcon i seguenti contenuti:

   $ 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. Clona defaultdall'account.

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

5. Clona accountBdall'account.

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

Vedi di più qui

Concordo con Tuomas sull'uso di ssh-agent. Volevo anche aggiungere una seconda chiave privata per il lavoro e questo tutorial ha funzionato come un incantesimo per me.

I passaggi sono i seguenti:

1. $ ssh-agent bash
2. $ ssh-add /path.to/private/key per esempio ssh-add ~/.ssh/id_rsa
3. Verifica entro $ ssh-add -l
4. Provalo con $ssh -v <host url>esssh -v git@assembla.com

Mi ero imbattuto in questo problema qualche tempo fa, quando avevo due account Bitbucket e volevo dover memorizzare chiavi SSH separate per entrambi. Questo è ciò che ha funzionato per me.

Ho creato due configurazioni ssh separate come segue.

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

Ora, quando ho dovuto clonare un repository dal mio account di lavoro, il comando era il seguente.

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

Ho dovuto modificare questo comando in:

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

Allo stesso modo il comando clone dal mio account personale ha dovuto essere modificato

git clone git @ personal .bitbucket.org: nome / personalproject.git

Fare riferimento a questo collegamento per ulteriori informazioni.

Usa ssh-agent per le tue chiavi.

Ora, con la versione recente di Git, possiamo specificare sshCommand nel file di configurazione Git specifico del repository:

  [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/*

Puoi creare un file di configurazione chiamato confignella tua ~/.sshcartella. Può contenere:

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

Questo ti permetterà di connetterti a macchine come questa

 ssh aws

IMPORTANTE: è necessario avviare ssh-agent

È necessario avviare ssh-agent (se non è già in esecuzione) prima di utilizzare ssh-add come segue:

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

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

Si noti che il comando eval avvia l'agente su Git Bash su Windows. Altri ambienti possono utilizzare una variante per avviare l'agente SSH.

Su Ubuntu 18.04 (Bionic Beaver) non c'è nulla da fare.

Dopo aver creato correttamente una seconda chiave SSH, il sistema proverà a trovare una chiave SSH corrispondente per ogni connessione.

Per essere chiari, puoi creare una nuova chiave con questi comandi:

# 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

Più coppie di chiavi su GitHub

1.0 file di configurazione SSH

1.1 Creare ~ / .ssh / config

1.2 chmod 600 ~ / .ssh / config ( obbligatorio )

1.3 Immettere quanto segue nel file:

Pizza ospitante

Nome host github.com

PreferredAuthentications publickey # opzionale

IdentityFile ~ / .ssh / privatekey1

Caso A: nuovo nuovo clone Git

Utilizzare questo comando per clonare Git:

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

Nota: se si desidera modificare il nome host "pizza" di .ssh / config in futuro, accedere alla cartella clonata Git, modificare la riga dell'URL del file .git / config (vedere il caso B)

Caso B: hai già la cartella clone di Git

2.1 Vai alla cartella clonata, quindi vai alla cartella .git

2.2 Modifica file di configurazione

2.3 Aggiorna l'URL da * vecchio a nuovo :

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

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

Per me, l'unica soluzione funzionante era semplicemente aggiungere questo nel file ~/.ssh/config:

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

your_ssh_keyè senza alcuna estensione. Non usare .pub.

Su CentOS 6.5 con OpenSSH_5.3p1 e OpenSSL 1.0.1e-fips, ho risolto il problema rinominando i miei file chiave in modo che nessuno di loro avesse il nome predefinito.

La mia directory .ssh contiene id_rsa_foo e id_rsa_bar, ma non id_rsa, ecc.

Come accennato in una pagina di blog Atlassian , genera un file di configurazione nella cartella .ssh , incluso il seguente testo:

#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

Quindi puoi semplicemente fare il checkout con il dominio suffisso e all'interno dei progetti puoi configurare i nomi degli autori, ecc. Localmente.

Ecco la soluzione che ho usato ispirata alla risposta di sajib-khan . La configurazione predefinita non è impostata; è il mio account personale su GitLab e l'altro specificato è il mio account aziendale. Ecco cosa ho fatto:

Genera la chiave SSH

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

Modifica la configurazione SSH

nano ~/.ssh/config

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

Elimina le chiavi SSH memorizzate nella cache

ssh-add -D

Provalo!

ssh -T git@company.gitlab.com

Benvenuto in GitLab, @ hugo.sohm!

ssh -T git@gitlab.com

Benvenuto in GitLab, @HugoSohm!

Usalo!

Conto aziendale

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

Account personale / predefinito

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

Ecco la fonte che ho usato.

Adoro l'approccio per impostare quanto segue nel file ~ / .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

Quindi nel tuo repository puoi creare un .envfile che contiene il sshcomando da usare:

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

Se poi usi ad esempio dotenv la variabile di ambiente viene esportata automaticamente e , puoi specificare la chiave che desideri per project / directory. La passphrase viene richiesta una sola volta poiché viene aggiunta al portachiavi.

Questa soluzione funziona perfettamente con Git ed è progettata per funzionare su un Mac (a causa di UseKeychain).

Puoi provare questo pacchetto sshmulti npm per mantenere più chiavi SSH.