risposta-alla-domanda-sullo-sviluppo-web-bd.com

Come specificare la chiave SSH privata da utilizzare quando si esegue il comando Shell su Git?

Una situazione piuttosto insolita, forse, ma voglio specificare una chiave SSH privata da usare quando si esegue un comando Shell (git) dal computer locale.

Fondamentalmente in questo modo: 

git clone [email protected]:TheUser/TheProject.git -key "/home/christoffer/ssh_keys/theuser"

O ancora meglio (in Ruby):

with_key("/home/christoffer/ssh_keys/theuser") do
  sh("git clone [email protected]:TheUser/TheProject.git")
end

Ho visto esempi di connessione a un server remoto con Net :: SSH che utilizza una chiave privata specificata, ma questo è un comando locale. È possibile?

811
Christoffer

Qualcosa del genere dovrebbe funzionare (suggerito da orip):

ssh-agent bash -c 'ssh-add /somewhere/yourkey; git clone [email protected]:user/project.git'

se preferisci le subshell, puoi provare quanto segue (anche se è più fragile):

ssh-agent $(ssh-add /somewhere/yourkey; git clone [email protected]:user/project.git)

Git invocherà SSH che troverà il suo agente in base alla variabile di ambiente; questo, a sua volta, avrà la chiave caricata.

In alternativa, l'impostazione di HOME può anche fare il trucco, a patto di voler installare una directory che contiene solo una directory .ssh come HOME; questo può contenere un identity.pub o un config file setting IdentityFile.

610
Martin v. Löwis

Nessuna di queste soluzioni ha funzionato per me. 

Invece, ho approfondito @Martin v. La menzione di Löwis sull'impostazione di un file config per SSH.

SSH cercherà il file ~/.ssh/config dell'utente. Ho il mio setup come:

Host gitserv
    Hostname remote.server.com
    IdentityFile ~/.ssh/id_rsa.github
    IdentitiesOnly yes # see NOTES below

E aggiungo un repository git remoto:

git remote add Origin [email protected]:myrepo.git

E quindi i comandi git funzionano normalmente per me.

git Push -v Origin master

GLI APPUNTI

  • IdentitiesOnly yes è richiesto per impedire il comportamento predefinito di SSH di inviare il file di identità che corrisponde al nome file predefinito per ciascun protocollo. Se hai un file chiamato ~/.ssh/id_rsa che verrà provato PRIMA del tuo ~/.ssh/id_rsa.github senza questa opzione.

Riferimenti

999
HeyWatchThis

I suggerimenti di altre persone su ~/.ssh/config sono molto complicati. Può essere semplice come:

Host github.com
  IdentityFile ~/.ssh/github_rsa
367
philfreo

A partire da Git 2.3.0 abbiamo anche il comando semplice (non è necessario alcun file di configurazione):

GIT_SSH_COMMAND='ssh -i private_key_file' git clone [email protected]:repo.git

Potrebbe essere necessario un riavvio per il servizio ssh sulla macchina.

295
Robert Jack Will

Contenuto di my_git_ssh_wrapper:

#!/bin/bash

ssh -i /path/to/ssh/secret/key $1 $2

Quindi puoi usare la chiave facendo:

GIT_SSH=my_git_ssh_wrapper git clone [email protected]:TheUser/TheProject.git
126
Joe Block

Per riassumere risposte e commenti , il modo migliore per impostare git per utilizzare diversi file chiave e poi dimenticarsene, che supporta anche diversi utenti per lo stesso host (ad esempio un account personale GitHub e uno di lavoro), che funziona anche su Windows, è quello di modificare ~/.ssh/config (o c:\Users\<your user>\.ssh\config) e specificare più identità:

Host github.com
HostName github.com
IdentityFile /path/to/your/personal/github/private/key
User dandv

Host github-work
HostName github.com
IdentityFile /path/to/your/work/github/private/key
User workuser

Quindi, per clonare un progetto come utente personale, esegui il normale comando git clone.

Per clonare il repository come workuser, eseguire git clone [email protected]:company/project.git.

81
Dan Dascalescu

Con git 2.10+ (Q3 2016: rilasciato il 2 settembre 2016), hai la possibilità di impostare un config per GIT_SSH_COMMAND (e non solo una variabile di ambiente come descritto in Rober Jack Will 's risposta )

Vedi commit 3c8ede3 (26 giu 2016) di Nguyễn Thái Ngọc Duy (pclouds) .
(Fuso da Junio ​​C Hamano - gitster - in commit dc21164 , 19 lug 2016)

Una nuova variabile di configurazione core.sshCommand è stata aggiunta a specificare quale valore deve essere utilizzato da GIT_SSH_COMMAND per repository.

core.sshCommand:

Se questa variabile è impostata, git fetch e git Push utilizzeranno il comando specificato invece di ssh quando devono connettersi a un sistema remoto.
Il comando è nella stessa forma della variabile di ambiente GIT_SSH_COMMAND e viene sovrascritto quando viene impostata la variabile di ambiente.

Significa che git clone può essere:

cd /path/to/my/repo
git config core.sshCommand 'ssh -i private_key_file' 
# later on
git clone Host:repo.git
65
VonC

Come indicato qui: https://superuser.com/a/912281/607049

Puoi configurarlo per-repo:

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

Sono andato con la variabile d'ambiente GIT_SSH . Ecco il mio wrapper, simile a quello di Joe Block dall'alto, ma gestisce qualsiasi quantità di argomenti.

File ~/gitwrap.sh

#!/bin/bash
ssh -i ~/.ssh/gitkey_rsa "[email protected]"

Quindi, nel mio .bashrc, aggiungi quanto segue:

export GIT_SSH=~/gitwrap.sh
30
Jamie

È una buona idea aggiungere l'host o l'ip al file .ssh/config in questo modo:

Host (a space separated list of made up aliases you want to use for the Host)
    User git
    Hostname (ip or hostname of git server)
    PreferredAuthentications publickey
    IdentityFile ~/.ssh/id_rsa_(the key you want for this repo)
28
thamster

Quando è necessario connettersi a github con una richiesta normale (git pull Origin master), l'impostazione dell'host come * in ~/.ssh/config ha funzionato per me, qualsiasi altro host (ad esempio "github" o "gb") non funzionava.

Host *
    User git
    Hostname github.com
    PreferredAuthentications publickey
    IdentityFile ~/.ssh/id_rsa_xxx
7
chopstik

Molte di queste soluzioni sembravano allettanti. Tuttavia, ho trovato che l'approccio generico git-wrapping-script al seguente link è il più utile:

Come specificare un file chiave ssh con il comando git

Il punto è che non esiste un comando git come il seguente:

git -i ~/.ssh/thatuserkey.pem clone [email protected]:/git/repo.git

La soluzione di Alvin è usare uno script bash-wrapper ben definito che colma questa lacuna:

git.sh -i ~/.ssh/thatuserkey.pem clone [email protected]:/git/repo.git

Dove git.sh è:

#!/bin/bash

# The MIT License (MIT)
# Copyright (c) 2013 Alvin Abad
# https://alvinabad.wordpress.com/2013/03/23/how-to-specify-an-ssh-key-file-with-the-git-command

if [ $# -eq 0 ]; then
    echo "Git wrapper script that can specify an ssh-key file
Usage:
    git.sh -i ssh-key-file git-command
    "
    exit 1
fi

# remove temporary file on exit
trap 'rm -f /tmp/.git_ssh.$$' 0

if [ "$1" = "-i" ]; then
    SSH_KEY=$2; shift; shift
    echo "ssh -i $SSH_KEY \[email protected]" > /tmp/.git_ssh.$$
    chmod +x /tmp/.git_ssh.$$
    export GIT_SSH=/tmp/.git_ssh.$$
fi

# in case the git command is repeated
[ "$1" = "git" ] && shift

# Run the git command
git "[email protected]"

Posso verificare che questo risolva un problema che ho riscontrato con il riconoscimento utente/chiave per un repository di bitbucket remoto con git remote update, git pull e git clone; tutto ciò ora funziona bene in uno script di lavoro cron che altrimenti avrebbe avuto problemi nella navigazione della shell limitata. Sono stato anche in grado di chiamare questo script dall'interno di R e comunque risolvere lo stesso cron eseguire il problema (Ad esempio system("bash git.sh -i ~/.ssh/thatuserkey.pem pull")).

Non che R sia uguale a Ruby, ma se R può farlo ... O :-)

7
Paul McMurdie

Se nessuna delle altre soluzioni qui funziona per te, e hai creato più ssh-keys, ma ancora non puoi fare cose semplici come

git pull

quindi supponendo che tu abbia due file di chiavi ssh come 

id_rsa
id_rsa_other_key

poi all'interno del repository git con cui stai lottando (cd in là), prova:

eval `ssh-agent -s`
ssh-add ~/.ssh/id_rsa
ssh-add ~/.ssh/id_rsa_other_key

e assicurati anche che il tuo nome utente e l'ID utente github siano corretti da:

# Run these commands INSIDE your git directory
git config user.name "Mona Lisa"
git config user.email "[email protected]"

Vedi https://Gist.github.com/jexchan/2351996 per ulteriori informazioni.

4
cgnorthcutt

GIT_SSH_COMMAND = "ssh -i/percorso/a/git-private-access-key" git clone $ git_repo

3
carlsborg

se hai una directory sul tuo percorso in cui vuoi firmare con un determinato file di identificazione, puoi specificare di utilizzare un file di identificazione specifico tramite il file .ssh/config impostando ControlPath e.g .:

Host github.com
  ControlPath ~/Projects/work/**
  HostName github.com
  IdentityFile ~/.ssh/id_work
  User git

Quindi ssh utilizzerà il file di identità specificato quando si eseguono i comandi git sotto il percorso di lavoro specificato.

3
cristobal

Il trucco per me era usare git @ hostname invece di http: // hostname

2
AmazingTurtle

In Windows con Git Bash è possibile utilizzare quanto segue per aggiungere un repository ssh-agent bash -c 'ssh-add "key-address"; git remote add Origin "rep-address"' Ad esempio: ssh-agent bash -c 'ssh-add /d/test/PrivateKey.ppk; git remote add Origin [email protected]:test/test.git' Quale chiave privata è nell'unità D, test della cartella del computer. Inoltre, se vuoi clonare un repository, puoi cambiare git remote add Origin con git clone.

Dopo averlo inserito in Git Bash, ti chiederà la passphrase!

Essere consapevoli del fatto che opensh private key e PuTTY private key sono diverse!

Se hai creato le tue chiavi con puttygen, devi convertire la tua chiave privata in openssh!

2
Peyman Mahdavi

Potresti usare la variabile d'ambiente GIT_SSH. Ma sarà necessario avvolgere ssh e opzioni in uno script di Shell.

Vedi il manuale di git: man git nel tuo comando Shell.

2
rudimeier

Ecco la chiave di accesso ssh che ho trovato durante la ricerca di una soluzione a questo problema:

Ad esempio hai 2 diversi set di chiavi:

key1, key1.pub, key2, key2.pub

Conserva queste chiavi nella tua directory .ssh

Ora nel file .bashrc o .bash_profile alias, aggiungi questi comandi

alias key1='cp ~/.ssh/key1 id_rsa && cp ~/.ssh/key1.pub id_rsa.pub'

alias key2='cp ~/.ssh/key2 id_rsa && cp ~/.ssh/key2.pub id_rsa.pub'

Ecco! Hai una scorciatoia per cambiare i tasti quando vuoi!

Spero che questo funzioni per te. 

1
penduDev

per gitlabRSAAuthentication yes 

Host gitlab.com
  RSAAuthentication yes
  IdentityFile ~/.ssh/your_private_key_name
  IdentitiesOnly yes

doc è qui

1
Alupotha

Devi creare un ~/.ssh/config come sotto

Host <Your bitbucket server>
User <userid>
Hostname <Your bitbucket server as above>
IdentitiesOnly yes
IdentityFile ~/.ssh/id_rsa<file> This is your private key file

permesso come sotto

-rw------- $HOME/.ssh/config

Aggiungi la tua chiave pubblica al tuo git (cat ~/.ssh/id_rsa_pub [o nome simillar])

e poi git clone come sotto

git clone ssh://[email protected]/userid/test.git
0
gajanan malvade

Il problema è quando hai diversi repository remoti sullo stesso host (ad esempio github.com), e vuoi interagire con loro usando diverse chiavi ssh (cioè diversi account GitHub).

Per farlo:

1) Per prima cosa dovresti dichiarare le tue diverse chiavi nel file ~/.ssh/config.

# Key for usual repositories on github.com
Host github.com
HostName github.com
User git
IdentityFile ~/.ssh/id_rsa

# Key for a particular repository on github.com
Host XXX
HostName github.com
User git
IdentityFile ~/.ssh/id_other_rsa

In questo modo si associa la seconda chiave con un nuovo nome descrittivo "XXX" per github.com.

2) Quindi è necessario modificare l'origine remota del repository specifico, in modo che utilizzi il nome descrittivo che hai definito.

Vai alla cartella del repository locale all'interno di un comando Prompt e visualizza l'origine remota corrente:

>git remote -v
Origin  [email protected]:myuser/myrepo.git (fetch)
Origin  [email protected]:myuser/myrepo.git (Push)

Quindi cambia origine con:

>git remote set-url Origin [email protected]:myuser/myrepo.git
>git remote -v
Origin  [email protected]:myuser/myrepo.git (fetch)
Origin  [email protected]:myuser/myrepo.git (Push)

Ora puoi premere, recuperare ... con la chiave giusta automaticamente.

0
rodo

Se il numero di porta SSH non è 22 (predefinito), aggiungere Port xx in ~/.ssh/config

Nel mio caso (sinologia),

Host my_synology
    Hostname xxxx.synology.me
    IdentityFile ~/.ssh/id_rsa_xxxx
    User myname
    Port xx

Quindi clonare usando il titolo Host in config. ("my_synology". per evitare "*" di @chopstik) 

git clone my_synology:path/to/repo.git
0
w..k

Uso zsh e chiavi diverse vengono caricate automaticamente su ssh-agent del mio zsh Shell per altri scopi (ad esempio l'accesso ai server remoti) sul mio laptop. Ho modificato la risposta di Nick e la sto utilizzando per uno dei miei repository che deve essere aggiornato spesso. (In questo caso è il mio dotfiles che voglio la stessa e l'ultima versione su tutte le mie macchine, ovunque io stia lavorando.)

bash -c 'eval `ssh-agent`; ssh-add /home/myname/.dotfiles/gitread; ssh-add -L; cd /home/myname/.dotfiles && git pull; kill $SSH_AGENT_PID'
  • Crea un agente ssh
  • Aggiungi la chiave di sola lettura all'agente
  • Cambia directory al mio repository git
  • Se cd to repo dir ha esito positivo, passa dal repository remoto
  • Uccidi spawned ssh-agent. (Non vorrei che molti degli agenti indugiassero in giro.)
0
sdkks

Se sei come me, puoi:

  • Mantieni le tue chiavi SSH organizzate

  • Tieni i tuoi comandi git clone semplici

  • Gestire qualsiasi numero di chiavi per qualsiasi numero di repository.

  • Riduci la manutenzione della tua chiave ssh.

Tengo le mie chiavi nella mia directory ~/.ssh/keys.

Preferisco la convenzione sulla configurazione.

Penso che il codice sia legge; più semplice è, meglio è.

STEP 1 - Crea alias

Aggiungi questo alias alla shell: alias git-clone='GIT_SSH=ssh_wrapper git clone'

STEP 2 - Crea script

Aggiungi questo script ssh_wrapper al tuo PATH:

#!/bin/bash
# Filename: ssh_wrapper

if [ -z ${SSH_KEY} ]; then
    SSH_KEY='github.com/l3x'  # <= Default key
fi
SSH_KEY="~/.ssh/keys/${SSH_KEY}/id_rsa"
ssh -i "${SSH_KEY}" "[email protected]"

ESEMPI

Usa la chiave github.com/l3x:

KEY=github.com/l3x git-clone https://github.com/l3x/learn-fp-go

L'esempio seguente utilizza anche il tasto github.com/l3x (per impostazione predefinita):

git-clone https://github.com/l3x/learn-fp-go

Usa la chiave bitbucket.org/lsheehan:

KEY=bitbucket.org/lsheehan git-clone [email protected]:dave_andersen/exchange.git

GLI APPUNTI

Cambia l'SSH_KEY predefinito nello script ssh_wrapper con quello che usi la maggior parte del tempo. In questo modo, non è necessario utilizzare la variabile KEY la maggior parte del tempo.

Potresti pensare: "Ehi! Questo sta succedendo molto con un alias, una sceneggiatura e qualche directory di chiavi", ma per me è una convenzione. Quasi tutte le mie workstation (e server per quella materia) sono configurate in modo simile.

Il mio obiettivo qui è quello di semplificare i comandi che eseguo regolarmente.

Le mie convenzioni, ad es. Script di Bash, alias e così via, creano un ambiente coerente e mi aiutano a mantenere le cose semplici.

BACIO e nomi contano.

Per ulteriori suggerimenti sul design, consulta Capitolo 4 SOLID Design in Go dal mio libro: https://www.Amazon.com/Learning-Functional-Programming-Lex-Sheehan-ebook/ dp/B0725B8MYW

Spero che sia d'aiuto. - Lex

0
l3x