Możesz poinstruować ssh, aby wypróbował kilka kluczy po kolei podczas łączenia. Oto jak:

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

W ten sposób nie musisz określać, który klucz działa z jakim serwerem. Użyje tylko pierwszego działającego klucza.

Również można wprowadzić hasło tylko wtedy, gdy dany serwer jest gotów zaakceptować klucz. Jak widać powyżej ssh nie próbował prosić o hasło dla .ssh/id_rsa, nawet jeśli je posiadał.

Na pewno nie prześciga konfiguracji na serwer jak w innych odpowiedziach, ale przynajmniej ty nie musisz dodawać konfiguracji dla wszystkich i każdego serwera, z którym się łączysz!

Odpowiedź Randala Schwartza prawie mi pomogła. Mam inną nazwę Użytkownika na serwerze, więc musiałem dodać słowo kluczowe User do mojego pliku:

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

Teraz możesz połączyć się używając przyjaznej nazwy:

ssh friendly-name

Więcej słów kluczowych można znaleźć na stronie OpenSSH man . uwaga: niektóre z wymienionych słów kluczowych mogą być już obecne w pliku /etc/ssh/ssh_config.

Poprzednie odpowiedzi poprawnie wyjaśniły sposób tworzenia pliku konfiguracyjnego do zarządzania wieloma kluczami ssh. Myślę, że ważną rzeczą, którą należy również wyjaśnić, jest zastąpienie nazwy hosta nazwą aliasu podczas klonowania repozytorium .

Załóżmy, że nazwa użytkownika Twojego konta GitHub firmy to abc1234 . Załóżmy, że nazwa użytkownika twojego konta na Githubie to jack1234

I załóżmy, że stworzyłeś dwa klucze RSA, a mianowicie id_rsa_company i id_rsa_personal. Tak więc Twój plik konfiguracyjny będzie wyglądał następująco:

# 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

Teraz, kiedy klonujesz repozytorium (nazwa demo) Z firmowego konta GitHub, adres URL repozytorium będzie wyglądał następująco:

Repo URL: [email protected]:abc1234/demo.git

Teraz, wykonując git clone, powinieneś zmodyfikować powyższy adres URL repozytorium jako:

git@company:abc1234/demo.git

Zauważ jak github.com jest teraz zastąpiony aliasem "firma", jak zdefiniowaliśmy w plik konfiguracyjny.

Podobnie, musisz zmodyfikować adres URL klonowania repozytorium na koncie osobistym w zależności od aliasu podanego w pliku konfiguracyjnym.

ssh-add ~/.ssh/xxx_id_rsa

Upewnij się, że przetestujesz go przed dodaniem z:

ssh -i ~/.ssh/xxx_id_rsa [email protected]

Jeśli masz jakieś problemy z błędami czasami zmiana bezpieczeństwa Pliku pomaga:

chmod 0600 ~/.ssh/xxx_id_rsa

1. Wygeneruj klucz SSH:

   $ ssh-keygen -t rsa -C <[email protected]>
   

2. Wygeneruj kolejny klucz SSH :

   $ ssh-keygen -t rsa -f ~/.ssh/accountB -C <[email protected]>
   

   Teraz dwa klucze publiczne (id_rsa.pub, accountB.pub ) powinien istnieć w katalogu ~/.ssh/.

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

3. Utwórz plik konfiguracyjny ~/.ssh/config o następującej treści:

   $ 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. Klon z default konta.

   $ git clone [email protected]:username/project.git
   

5. Klon z accountB konto.

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

Zobacz Więcej Tutaj

Zgadzam się z Tuomasem co do używania SSH-agenta. Chciałem również dodać drugi klucz prywatny do pracy i ten tutorial zadziałał jak urok dla mnie.

Kroki są następujące:

1. $ ssh-agent bash
2. $ ssh-add /path.to/private/key e. g ssh-add ~/.ssh/id_rsa
3. zweryfikuj przez $ ssh-add -l
4. Przetestuj z $ssh -v <host url> np ssh -v [email protected]

Napotkałem ten problem jakiś czas temu, kiedy miałem dwa konta Bitbucket i chciałem przechowywać oddzielne klucze SSH dla obu. To mi się udało.

Utworzyłem dwie oddzielne konfiguracje ssh w następujący sposób.

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

Teraz, kiedy musiałem sklonować repozytorium z mojego konta roboczego-polecenie było następujące.

git clone [email protected]:teamname/project.git

Musiałem zmodyfikować to polecenie do:

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

Podobnie polecenie klonowania z mojego konta osobistego musiało zostać zmodyfikowane do

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

Zobacz ten link aby uzyskać więcej informacji.

Teraz, w najnowszej wersji Git, możemy określić sshCommand w pliku konfiguracyjnym Git specyficznym dla repozytorium:

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

Użyj ssh-agent dla kluczy.

Oto rozwiązanie, którego użyłem zainspirowany odpowiedzią sajib-Khana. Domyślna konfiguracja nie jest ustawiona; jest to moje konto osobiste na GitLab , a inne podane to moje konto firmowe. Oto co zrobiłem:

Wygeneruj klucz SSH

ssh-keygen -t rsa -f ~/.ssh/company -C "[email protected]"

Edycja konfiguracji SSH

nano ~/.ssh/config

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

Usuń buforowany klucz(y) SSH

ssh-add -D

Przetestuj to!

ssh -T [email protected]

Witaj w GitLab, @ hugo.sohm!

ssh -T [email protected]

Witaj w GitLab, @ HugoSohm!

Użyj go!

Konto Firmowe

git clone [email protected]:group/project.git

Konto osobiste/domyślne

git clone [email protected]:username/project.git

Oto źródło , którego użyłem.

Wiele par kluczy na Githubie

1.0 Plik konfiguracyjny SSH

1.1 Create ~/.ssh / config

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

1.3 wprowadź do pliku:

Host pizza

Nazwa hosta github.com

PreferredAuthentications publickey # optional

IdentityFile ~/.ssh / privatekey1

Case A: Fresh new git clone

Użyj tego polecenie do Git clone:

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

Uwaga: Jeśli chcesz zmienić nazwę hosta" pizza " z .ssh / config w przyszłości, przejdź do sklonowanego folderu Git, edytuj .wiersz adresu URL pliku Git/config (patrz case B)

Przypadek B: masz już folder Git clone

2.1 przejdź do sklonowanego folderu, a następnie przejdź do .Git folder

2.2 Edycja pliku konfiguracyjnego

2.3 zaktualizuj adres URL z * old na new :

(Old) URL = [email protected]:yourgitusername/pizzahut_repo.git

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

Dla mnie jedynym działającym rozwiązaniem było po prostu dodanie tego w pliku ~/.ssh/config:

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

your_ssh_key jest bez rozszerzenia. Nie używaj .pub.

Możesz utworzyć plik konfiguracyjny o nazwie config w folderze ~/.ssh. Może zawierać:

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

To pozwoli Ci połączyć się z takimi maszynami

 ssh aws

Ważne: musisz uruchomić ssh-agent

Przed użyciem ssh-add należy uruchomić ssh-agent (jeśli nie jest już uruchomiony) w następujący sposób:

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

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

Zauważ, że polecenie eval uruchamia agenta na Git Bash w systemie Windows. Inne Środowiska mogą użyć wariantu do uruchomienia agenta SSH.

Na Ubuntu 18.04 (Bionic Beaver) nie ma co robić.

Po pomyślnym utworzeniu drugiego klucza SSH system spróbuje znaleźć pasujący klucz SSH dla każdego połączenia.

Aby było jasne, możesz utworzyć nowy klucz za pomocą tych poleceń:

# 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

Uwielbiam podejście, aby ustawić następujące w pliku ~/.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

Następnie w repozytorium możesz utworzyć plik .env zawierający polecenie ssh do użycia:

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

Jeśli użyjesz np. dotenv środowisko zmienna środowiskowa jest eksportowana automatycznie i whoop whoop, możesz określić klucz, który chcesz dla projektu / katalogu. Hasło jest wymagane tylko raz, ponieważ jest dodawane do pęku kluczy.

To rozwiązanie doskonale współpracuje z Git i jest przeznaczony do pracy na Macu(ze względu na UseKeychain).

Dla tych, którzy pracują z aws Gorąco polecam pracę z instancją EC2 Connect.

Amazon EC2 Instance Connect zapewnia prosty i bezpieczny sposób łączenia się z instancjami za pomocą Secure Shell (SSH).

Dzięki rozwiązaniu EC2 Instance Connect możesz używać zasad i zasad AWS Identity and Access Management (IAM) do kontrolowania dostępu SSH do instancji, eliminując potrzebę udostępniania kluczy SSH i zarządzania nimi.

Po zainstalowaniu odpowiednie pakiety (pip install ec2instanceconnectcli lub klonowanie bezpośrednio repo ) możesz bardzo łatwo połączyć się z wieloma instancjami EC2, zmieniając po prostu ID instancji :

Co dzieje się za kulisami?

Gdy łączysz się z instancją za pomocą EC2 Instance Connect, API Instance Connect wypycha jednorazowy klucz publiczny SSH do metadanych instancji, gdzie pozostaje przez 60 sekund. Polityka IAM dołączona do użytkownika IAM upoważnia użytkownika IAM, aby wcisnąć klucz publiczny do metadanych instancji.

Demon SSH używa AuthorizedKeysCommand i AuthorizedKeysCommandUser, które są skonfigurowane podczas instalacji Instance Connect, aby wyszukać klucz publiczny z metadanych instancji w celu uwierzytelnienia i połączyć cię z instancją.

(*) Amazon Linux 2 2.0.20190618 lub nowszy, a Ubuntu 20.04 lub nowszy jest wstępnie skonfigurowany z instancją EC2 Connect. W przypadku innych obsługiwanych dystrybucji Linuksa należy skonfigurować Instance Connect dla każdego wystąpienia, które będzie obsługiwać za pomocą Instance Connect. Jest to wymóg jednorazowy dla każdej instancji.

Linki:

Konfiguracja instancji EC2 Connect
Połącz za pomocą instancji EC2 Connect
zabezpieczanie hostów bastionowych za pomocą instancji Amazon EC2 Connect

Na CentOS 6.5 uruchamiając OpenSSH_5. 3P1 i OpenSSL 1.0.1 e-fips, rozwiązałem problem zmieniając nazwy moich plików kluczy tak, że żaden z nich nie miał domyślnej nazwy.

My .katalog SSH zawiera id_rsa_foo i id_rsa_bar, ale nie ma id_rsa, itp.

Jak wspomniano na stronie bloga Atlassian , wygenerować plik config wewnątrz .folder ssh , zawierający następujący tekst:

#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

Następnie możesz po prostu dokonać zakupu za pomocą domeny sufiksu i w ramach projektów możesz skonfigurować nazwy autorów itp. lokalnie.

Możesz wypróbować Ten Pakiet sshmulti npm do obsługi wielu kluczy SSH.