Ich möchte mehrere private Schlüssel verwenden, um eine Verbindung zu verschiedenen Servern oder verschiedenen Teilen desselben Servers herzustellen (meine Verwendungszwecke sind Systemadministration des Servers, Verwaltung von Git und normale Git-Nutzung innerhalb desselben Servers). Ich habe versucht, einfach die Schlüssel in den id_rsaDateien zu stapeln , ohne Erfolg.

Anscheinend ist eine einfache Möglichkeit, dies zu tun, die Verwendung des Befehls

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

Das ist ziemlich umständlich.

Irgendwelche Vorschläge, wie man das etwas einfacher macht?

Von meinem .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

Und so weiter.

Sie können ssh anweisen, beim Verbinden mehrere Schlüssel nacheinander auszuprobieren. Hier ist wie:

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

Auf diese Weise müssen Sie nicht angeben, welcher Schlüssel mit welchem ​​Server funktioniert. Es wird nur der erste Arbeitsschlüssel verwendet.

Außerdem würden Sie nur dann eine Passphrase eingeben, wenn ein bestimmter Server bereit ist, den Schlüssel zu akzeptieren. Wie oben gezeigt, hat ssh nicht versucht, nach einem Passwort zu fragen, .ssh/id_rsaauch wenn es eines hatte.

Sicherlich übertrifft es eine Konfiguration pro Server nicht wie in anderen Antworten, aber zumindest müssen Sie keine Konfiguration für alle Server hinzufügen, mit denen Sie eine Verbindung herstellen!

Die Antwort von Randal Schwartz hat mir fast den ganzen Weg geholfen. Ich habe einen anderen Benutzernamen auf dem Server, daher musste ich meiner Datei das Schlüsselwort User hinzufügen :

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

Jetzt können Sie eine Verbindung mit dem Anzeigenamen herstellen:

ssh friendly-name

Weitere Schlüsselwörter finden Sie auf der OpenSSH-Manpage . HINWEIS: Einige der aufgelisteten Schlüsselwörter sind möglicherweise bereits in Ihrer Datei / etc / ssh / ssh_config vorhanden .

In den vorherigen Antworten wurde die Art und Weise, wie eine Konfigurationsdatei zum Verwalten mehrerer SSH-Schlüssel erstellt wird, ordnungsgemäß erläutert. Ich denke, das Wichtigste, was ebenfalls erklärt werden muss, ist das Ersetzen eines Hostnamens durch einen Aliasnamen beim Klonen des Repositorys .

Angenommen, der Benutzername des GitHub-Kontos Ihres Unternehmens lautet abc1234 . Angenommen, der Benutzername Ihres persönlichen GitHub-Kontos lautet jack1234

Angenommen, Sie haben zwei RSA-Schlüssel erstellt, nämlich id_rsa_company und id_rsa_personal . Ihre Konfigurationsdatei sieht also wie folgt aus:

# 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

Wenn Sie nun das Repository (benannte Demo) vom GitHub-Konto des Unternehmens klonen , lautet die Repository-URL wie folgt:

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

Währenddessen git clonesollten Sie die obige Repository-URL wie folgt ändern:

git@company:abc1234/demo.git

Beachten Sie, wie github.com jetzt durch den Alias ​​"Firma" ersetzt wird, wie wir ihn in der Konfigurationsdatei definiert haben.

Ebenso müssen Sie die Klon-URL des Repositorys im persönlichen Konto abhängig vom in der Konfigurationsdatei angegebenen Alias ​​ändern.

foo:~$ssh-add ~/.ssh/xxx_id_rsa

Stellen Sie sicher, dass Sie es testen, bevor Sie Folgendes hinzufügen:

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

Wenn Sie Probleme mit Fehlern haben, hilft manchmal das Ändern der Sicherheit der Datei:

chmod 0600 ~/.ssh/xxx_id_rsa

1. SSH-Schlüssel generieren:

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

2. Generieren another SSH key:

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

   Jetzt sollten zwei öffentliche Schlüssel ( id_rsa.pub , accountB.pub ) im ~/.ssh/Verzeichnis vorhanden sein.

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

3. Erstellen Sie eine Konfigurationsdatei ~/.ssh/configmit folgendem Inhalt:

   $ 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. Vom defaultKonto klonen .

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

5. Vom accountBKonto klonen .

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

Sehen Sie hier mehr

Ich würde Tuomas bezüglich der Verwendung von ssh-agent zustimmen. Ich wollte auch einen zweiten privaten Schlüssel für die Arbeit hinzufügen, und dieses Tutorial hat mir sehr gut gefallen.

Die Schritte sind wie folgt:

1. $ ssh-agent bash
2. $ ssh-add /path.to/private/key z.B ssh-add ~/.ssh/id_rsa
3. Überprüfen durch $ ssh-add -l
4. Testen Sie es mit $ssh -v <host url>zssh -v git@assembla.com

Ich war vor einiger Zeit auf dieses Problem gestoßen, als ich zwei Bitbucket-Konten hatte und separate SSH-Schlüssel für beide speichern wollte. Das hat bei mir funktioniert.

Ich habe zwei separate SSH-Konfigurationen wie folgt erstellt.

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

Als ich nun ein Repository von meinem Arbeitskonto klonen musste, lautete der Befehl wie folgt.

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

Ich musste diesen Befehl ändern, um:

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

Ebenso musste der Klonbefehl von meinem persönlichen Konto auf geändert werden

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

Weitere Informationen finden Sie unter diesem Link .

Verwenden Sie ssh-agent für Ihre Schlüssel.

Mit der neuesten Version von git können wir jetzt sshCommand in der repository-spezifischen git-Konfigurationsdatei angeben .

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

WICHTIG: Sie müssen ssh-agent starten

Sie müssen ssh-agent starten (falls es noch nicht ausgeführt wird), bevor Sie ssh-add wie folgt verwenden:

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

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

Beachten Sie, dass der Befehl eval den Agenten bei GIT-Bash unter Windows startet. Andere Umgebungen verwenden möglicherweise eine Variante, um den SSH-Agenten zu starten.

Sie können eine Konfigurationsdatei mit dem Namen configin Ihrem ~/.sshOrdner erstellen . Es kann enthalten:

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

Auf diese Weise können Sie eine Verbindung zu solchen Computern herstellen

 ssh aws

Am Ubuntu 18.04 gibt es nichts zu tun.

Nachdem ein zweiter SSH-Schlüssel erfolgreich erstellt wurde, versucht das System, für jede Verbindung einen passenden SSH-Schlüssel zu finden.

Um klar zu sein, können Sie mit diesen Befehlen einen neuen Schlüssel erstellen

# 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

Mehrere Schlüsselpaare in GITHUB

1.0 SSH-KONFIG-DATEI

1.1 CREATE ~ / .ssh / config

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

1.3 Eingabe folgend in die Datei:

Host Pizza

Hostname github.com

PreferredAuthentications publickey # optional

IdentityFile ~ / .ssh / privatekey1

Fall A: FRESH NEW GIT CLONE

Verwenden Sie diesen Befehl, um einen Klon zu erstellen:

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

Hinweis: Wenn Sie den Hostnamen "pizza" von .ssh / config in Zukunft ändern möchten, gehen Sie in den geklonten git-Ordner und bearbeiten Sie die URL-Zeile der .git / config-Datei (siehe Fall B).

Fall B: HABEN SIE BEREITS GIT CLONE FOLDER

2.1 Wechseln Sie in den geklonten Ordner und dann in den Ordner .git

2.2 Konfigurationsdatei bearbeiten

2.3 Aktualisieren Sie die URL von Alt auf Neu:

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

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

Für mich war die einzige funktionierende Lösung, einfach hinzuzufügen ~/.ssh/config

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

your_ssh_key ist ohne Erweiterung, nicht verwenden .pub

Unter Centos 6.5 mit OpenSSH_5.3p1, OpenSSL 1.0.1e-fips habe ich das Problem gelöst, indem ich meine Schlüsseldateien so umbenannt habe, dass keine von ihnen den Standardnamen hatte. Mein .ssh-Verzeichnis enthält id_rsa_foo und id_rsa_bar, aber keine id_rsa usw.

Wie auf der atlassianischen Blog-Seite erwähnt, generieren Sie eine Konfiguration in .ssh mit dem folgenden Text:

#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

Anschließend können Sie einfach mit der Suffixdomäne auschecken und innerhalb der Projekte die Autorennamen usw. lokal konfigurieren.

Sie können dieses sshmulti npm-Paket ausprobieren, um mehrere ssh-Schlüssel zu verwalten.

Hier ist die Lösung, die ich verwendet habe, inspiriert von der Antwort von @ sajib-khan. Die Standardkonfiguration ist nicht festgelegt, es ist mein persönliches Konto bei gitlab und das andere angegebene ist mein Firmenkonto. Hier was ich getan habe:

Generieren Sie den SSH-Schlüssel

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

Bearbeiten Sie die SSH-Konfiguration

nano ~/.ssh/config

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

Löschen Sie zwischengespeicherte SSH-Schlüssel.

ssh-add -D

Probier es aus !

ssh -T git@company.gitlab.com

Willkommen bei GitLab, @ hugo.sohm!

ssh -T git@gitlab.com

Willkommen bei GitLab, @HugoSohm!

Benutze es !

Firmenkonto

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

Persönliches / Standardkonto

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

Hier ist die Quelle , die ich verwendet habe, hoffe es hilft!

Ich liebe den Ansatz, Folgendes in ~ / .ssh / config festzulegen:

# Config 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 repo works and sometimes the other depending on which key is used first.
#  AddKeysToAgent yes
# I only use my private id file so all private repos don't need the env var `GIT_SSH_COMMAND="ssh -i ~/.ssh/id_rsa"` to be set.
  IdentityFile ~/.ssh/id_rsa

Dann können Sie in Ihrem Repo eine .envDatei erstellen , die den zu verwendenden Befehl ssh enthält:

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

Wenn Sie dann zB dotenv verwenden, wird die Umgebungsvariable automatisch exportiert und whoop whoop Sie können den gewünschten Schlüssel pro Projekt / Verzeichnis angeben. Die Pasphrase wird nur einmal abgefragt, da sie dem Schlüsselbund hinzugefügt wird.

Diese Lösung funktioniert perfekt mit Git und wurde entwickelt, um auf einem Mac zu funktionieren (aufgrund von UseKeychain).