sshmemiliki -iopsi untuk memberi tahu file kunci pribadi mana yang akan digunakan ketika mengautentikasi:

-i identity_file

Memilih file dari mana identitas (kunci pribadi) untuk RSA atau otentikasi DSA dibaca. Standarnya adalah ~/.ssh/identityuntuk protokol versi 1, dan ~/.ssh/id_rsadan ~/.ssh/id_dsauntuk protokol versi 2. File identitas juga dapat ditentukan berdasarkan per-host di file konfigurasi. Dimungkinkan untuk memiliki banyak -iopsi (dan banyak identitas yang ditentukan dalam file konfigurasi).

Apakah ada cara serupa untuk mengetahui gitfile kunci pribadi mana yang akan digunakan pada sistem dengan beberapa kunci pribadi dalam ~/.sshdirektori?

Di ~/.ssh/config, tambahkan:

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

Sekarang kamu bisa melakukannya git clone git@github.com:username/repo.git.

CATATAN: Pastikan bahwa izin pada IdentityFile adalah 400. SSH akan menolak, dengan cara yang tidak jelas eksplisit, kunci SSH yang terlalu mudah dibaca. Itu hanya akan terlihat seperti penolakan kredensial. Solusinya, dalam hal ini, adalah:

chmod 400 ~/.ssh/id_rsa_github

Variabel lingkungan GIT_SSH_COMMAND:

Dari Git versi 2.3.0, Anda dapat menggunakan variabel lingkungan GIT_SSH_COMMANDseperti ini:

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

Perhatikan bahwa -iterkadang dapat ditimpa oleh file konfigurasi Anda, dalam hal ini, Anda harus memberikan SSH file konfigurasi kosong, seperti ini:

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

Konfigurasi core.sshCommand:

Dari Git versi 2.10.0, Anda dapat mengonfigurasi ini per repo atau secara global, sehingga Anda tidak perlu lagi mengatur variabel lingkungan!

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

Tidak ada cara langsung untuk mengetahui gitkunci privat mana yang digunakan, karena ini bergantung pada sshotentikasi repositori. Namun, masih ada beberapa cara untuk mencapai tujuan Anda:

Pilihan 1: ssh-agent

Anda dapat menggunakan ssh-agentuntuk sementara mengotorisasi kunci pribadi Anda.

Sebagai contoh:

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

Pilihan 2: GIT_SSH_COMMAND

Lewati argumen ssh dengan menggunakan GIT_SSH_COMMANDvariabel lingkungan (Git 2.3.0+).

Sebagai contoh:

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

_{Anda dapat mengetikkan ini semua dalam satu baris - abaikan $dan tinggalkan \.}

Opsi 3: GIT_SSH

Lewati argumen ssh dengan menggunakan GIT_SSHvariabel lingkungan untuk menentukan sshbiner alternatif .

Sebagai contoh:

$ 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

_{Catatan: Baris di atas adalah baris perintah shell (terminal) yang harus Anda tempelkan ke terminal Anda. Mereka akan membuat file dengan nama ssh, membuatnya dapat dieksekusi, dan (secara tidak langsung) menjalankannya.}

^{Catatan: GIT_SSHtersedia sejak v0.99.4 (2005).}

Opsi 4: ~/.ssh/config

Gunakan ~/.ssh/configfile seperti yang disarankan dalam jawaban lain untuk menentukan lokasi kunci pribadi Anda, mis

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

Tulis skrip yang memanggil sshargumen yang Anda inginkan, dan masukkan nama file skrip $GIT_SSH. Atau cukup masukkan konfigurasi Anda ~/.ssh/config.

Jika Anda tidak ingin harus menentukan variabel lingkungan setiap kali Anda menjalankan git, tidak ingin skrip pembungkus lain, tidak / tidak dapat menjalankan ssh-agent (1), atau ingin mengunduh paket lain hanya untuk ini, gunakan git -remote-ext (1) transportasi eksternal:

$ 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)

Saya menganggap solusi ini lebih unggul karena:

• Ini khusus repositori / jarak jauh
• Hindari bungkus skrip pembungkus
• Tidak perlu agen SSH - berguna jika Anda ingin klon / push / pull yang tidak dijaga (misalnya dalam cron)
• Jelas, tidak ada alat eksternal yang dibutuhkan

Gunakan konfigurasi host kustom ~/.ssh/config, seperti ini:

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

lalu gunakan nama host khusus Anda seperti ini:

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

Setelah perjuangan saya dengan $GIT_SSHsaya ingin berbagi apa yang berhasil untuk saya.

Melalui contoh saya, saya akan menganggap Anda memiliki kunci pribadi Anda di/home/user/.ssh/jenkins

Kesalahan yang harus dihindari: Nilai GIT_SSH mencakup opsi

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

atau apa pun yang serupa akan gagal, karena git akan mencoba mengeksekusi nilai sebagai file . Karena itu, Anda harus membuat skrip.

Contoh skrip $ GIT_SSH yang berfungsi /home/user/gssh.sh

Script akan dipanggil sebagai berikut:

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

Contoh kerja skrip dapat terlihat seperti:

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

Perhatikan $*pada bagian akhir, ini adalah bagian yang penting.

Alternatif yang lebih aman, yang akan mencegah kemungkinan konflik dengan apa pun di file konfigurasi default Anda (plus menyebutkan port yang akan digunakan secara eksplisit) adalah:

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

Dengan asumsi skrip berada /home/user/gssh.sh, Anda harus:

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

dan semua akan bekerja.

Anda bisa menggunakan ssh-ident daripada membuat pembungkus Anda sendiri.

Anda dapat membaca lebih lanjut di: https://github.com/ccontavalli/ssh-ident

Itu memuat kunci ssh sesuai permintaan saat pertama kali diperlukan, sekali, bahkan dengan beberapa sesi login, xterms atau NFS berbagi rumah.

Dengan file konfigurasi mungil, ia dapat secara otomatis memuat kunci yang berbeda dan memisahkannya di agen yang berbeda (untuk penerusan agen) tergantung pada apa yang perlu Anda lakukan.

Saya punya klien yang membutuhkan akun github terpisah. Jadi saya perlu menggunakan kunci terpisah hanya untuk proyek yang satu ini.

Solusi saya adalah menambahkan ini ke .zshrc / .bashrc saya:

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

Setiap kali saya ingin menggunakan git untuk proyek itu, saya mengganti "infogit" dengan git:

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

Bagi saya, lebih mudah diingat.

Jadi saya mengatur variabel env GIT_SSH ke $HOME/bin/git-ssh.

Untuk mendukung agar konfigurasi repo saya menentukan identitas ssh yang akan digunakan, ~/bin/git-sshfile saya adalah ini:

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

Maka saya memiliki pengaturan konfigurasi git global:

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

Dan di dalam repositori git apa pun saya hanya bisa menetapkan ssh.identitynilai konfigurasi git lokal :

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

Voila!

Jika Anda dapat memiliki alamat email yang berbeda untuk setiap identitas, itu menjadi lebih sederhana, karena Anda bisa memberi nama kunci Anda setelah alamat email Anda dan kemudian memiliki pengguna git config. Email mendorong pemilihan kunci dalam ~/bin/git-sshseperti ini:

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

Solusi saya adalah ini:

buat skrip:

#!/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

maka ketika Anda harus mengubah var run:

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

Jangan lupa titik ekstra !! ini membuat skrip mengatur environment vars !! --key dan --port adalah opsional.

Secara umum, Anda ingin menggunakannya ~/.ssh/configuntuk ini. Cukup pasangkan alamat server dengan kunci yang ingin Anda gunakan sebagai berikut:

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

Host *menunjukkan server apa pun, jadi saya menggunakannya untuk menetapkan ~/.ssh/id_rsasebagai kunci default untuk digunakan.

Saya membangun @shellholic dan utas SO ini dengan beberapa jati. Saya menggunakan GitHub sebagai contoh dan menganggap bahwa Anda memiliki kunci pribadi di ~/.ssh/github(jika tidak, lihat utas SO ini ) dan bahwa Anda menambahkan kunci publik ke profil GitHub Anda (jika tidak lihat bantuan GitHub ).

Jika perlu, buat file konfigurasi SSH baru di ~/.ssh/configdan ubah izin menjadi 400

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

Tambahkan ini ke ~/.ssh/configfile:

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

Jika Anda sudah memiliki pengaturan jarak jauh, Anda mungkin ingin menghapusnya, jika tidak Anda masih akan diminta nama pengguna dan kata sandi:

git remote rm origin

Kemudian tambahkan remote ke repositori git, dan perhatikan titik dua di depan nama pengguna:

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

Dan kemudian perintah git bekerja secara normal, misalnya:

git push origin master
git pull origin 

@HeyWatchThis pada utas SO ini menyarankan IdentitiesOnly yesuntuk menambahkan untuk mencegah perilaku default SSH mengirim file identitas yang cocok dengan nama file default untuk setiap protokol. Lihat utas itu untuk informasi dan referensi lebih lanjut.

Cukup gunakan ssh-agentdan ssh-addperintah.

# create an agent
ssh-agent

# add your default key
ssh-add ~/.ssh/id_rsa

# add your second key
ssh-add ~/.ssh/<your key name>

Setelah menjalankan perintah di atas, Anda dapat menggunakan kedua tombol secara bersamaan. Ketik saja

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

untuk mengkloning repositori Anda.

Anda perlu menjalankan perintah di atas setelah Anda me-reboot mesin Anda.

Saya menggunakan git versi 2.16 dan saya tidak perlu satu skrip bahkan perintah konfigurasi atau modifikasi.

• Baru saja menyalin kunci pribadi saya ke .ssh / id_rsa
• setel izin ke 600

Dan git membaca ke tombol secara otomatis. Saya tidak bertanya apa-apa dan itu tidak menimbulkan kesalahan. Hanya bekerja dengan baik.

Meskipun pertanyaannya tidak meminta, saya menyertakan jawaban ini untuk orang lain yang ingin menyelesaikan masalah yang sama hanya khusus untuk gitlab .

Solusi gitlab

Saya mencoba menggunakan pendekatan variabel lingkungan , tetapi bahkan dokumentasi git merekomendasikan ~/.ssh/configuntuk menggunakan apa pun selain kasus sederhana. Dalam kasus saya, saya mendorong ke server gitlab - dan saya ingin melakukannya sebagai pengguna tertentu - yang tentu saja ditentukan oleh kunci pribadi selama otentikasi dan bukan nama pengguna git. Setelah diimplementasikan saya cukup melakukan hal berikut:

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

Mempersiapkan

Ingat lokasi kunci pribadi Anda /myfolder/.ssh/my_gitlab_id_rsadalam kasus saya.

Tambahkan entri di ~/.ssh/config:

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

Tambahkan alias git di ~/.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"

Sebagai bonus, saya melakukan komit saya pada host yang sama dengan pengguna khusus dengan alias git ini :

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

Penjelasan

Semua hal di atas mengasumsikan remote yang relevan adalah origindan cabang yang relevan sedang diperiksa. Untuk referensi saya menemukan beberapa item yang perlu ditangani:

• Solusinya memerlukan membuat remote baru gitlab_as_me, dan saya tidak suka melihat remote tambahan berkeliaran di pohon log saya jadi saya menghapusnya ketika selesai
• Untuk membuat remote, ada kebutuhan untuk menghasilkan url remote dengan cepat - dalam kasus gitlab ini dicapai dengan bash cut sederhana
• Saat melakukan push to gitlab_as_meAnda harus spesifik tentang apa cabang yang Anda dorong
• Setelah melakukan push, originpointer lokal Anda harus "diperbarui" untuk mencocokkan gitlab_as_me( git pull origin $branchapakah ini)

Ketika Anda memiliki beberapa akun git dan Anda ingin kunci ssh yang berbeda

Anda harus mengikuti langkah yang sama untuk menghasilkan kunci ssh, tetapi pastikan Anda

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

Masukkan jalur yang ingin Anda simpan (Mis: my-pc / Desktop / .ssh / ed25519)

Tambahkan kunci publik ke gitlab Anda ( Cara menambahkan kunci ssh ke gitlab )

Anda harus identitas ssh baru menggunakan perintah di bawah ini

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