web-dev-qa-db-fra.com

Comment spécifier la clé SSH privée à utiliser lors de l'exécution de la commande Shell sur Git?

Une situation plutôt inhabituelle peut-être, mais je veux spécifier une clé SSH privée à utiliser lors de l'exécution d'une commande Shell (git) à partir de l'ordinateur local.

Fondamentalement, comme ceci: 

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

Ou même mieux (en rubis):

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

J'ai vu des exemples de connexion à un serveur distant avec Net :: SSH qui utilise une clé privée spécifiée, mais il s'agit d'une commande locale. C'est possible?

gitbashshellssh
811
Christoffer

Quelque chose comme ça devrait marcher (suggéré par orip):

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

si vous préférez les sous-coquilles, vous pouvez essayer les solutions suivantes (même s’il est plus fragile):

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

Git appellera SSH qui trouvera son agent par variable d’environnement; la clé sera chargée à son tour.

Sinon, définir HOME peut également faire l'affaire, à condition que vous souhaitiez configurer un répertoire contenant uniquement un répertoire .ssh sous la forme HOME; cela peut contenir soit identity.pub, soit un fichier config setting IdentityFile.

610
Martin v. Löwis

Aucune de ces solutions n'a fonctionné pour moi. 

Au lieu de cela, j'explique plus en détail la mention de @Martin v. Löwis de la définition d'un fichier config pour SSH.

SSH recherchera le fichier ~/.ssh/config de l'utilisateur. J'ai la configuration de la mine en tant que:

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

Et j'ajoute un dépôt git distant:

git remote add Origin git@gitserv:myrepo.git

Et puis les commandes git fonctionnent normalement pour moi.

git Push -v Origin master

REMARQUES

  • Le IdentitiesOnly yes est requis pour empêcher le comportement par défaut de SSH d'envoyer le fichier d'identité correspondant au nom de fichier par défaut pour chaque protocole. Si vous avez un fichier nommé ~/.ssh/id_rsa qui sera essayé AVANT votre ~/.ssh/id_rsa.github sans cette option.

Références

999
HeyWatchThis

Les suggestions d'autres personnes concernant ~/.ssh/config sont extrêmement compliquées. Cela peut être aussi simple que:

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

Depuis Git 2.3.0, nous avons également la commande simple (aucun fichier de configuration nécessaire):

GIT_SSH_COMMAND='ssh -i private_key_file' git clone user@Host:repo.git

Vous aurez peut-être besoin d'un redémarrage pour le service SSH sur votre machine.

295
Robert Jack Will

Contenu de my_git_ssh_wrapper:

#!/bin/bash

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

Ensuite, vous pouvez utiliser la clé en faisant:

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

Pour résumer les réponses et commentaires , le meilleur moyen de configurer git pour qu’il utilise différents fichiers de clés, puis l’oublie, ce qui prend également en charge différents utilisateurs pour le même hôte (par exemple un compte personnel GitHub et un compte professionnel), qui fonctionne également sous Windows, consiste à éditer ~/.ssh/config (ou c:\Users\<your user>\.ssh\config) et à spécifier plusieurs identités:

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

Ensuite, pour cloner un projet en tant qu’utilisateur personnel, exécutez simplement la commande git clone standard.

Pour cloner le référentiel en tant que workuser, exécutez git clone git@github-work:company/project.git.

81
Dan Dascalescu

Avec git 2.10+ (Q3 2016: publié le 2 sept. 2016), vous avez la possibilité de définir un config pour GIT_SSH_COMMAND (et pas seulement une variable d'environnement comme décrit dans Rober Jack Will ' réponse )

Voir commit 3c8ede3 (26 juin 2016) de Nguyễn Thái Ngọc Duy (pclouds) .
(Fusion par Junio ​​C Hamano - gitster - in commit dc21164 , 19 juil. 2016)

Une nouvelle variable de configuration core.sshCommand a été ajoutée à spécifiez quelle valeur pour GIT_SSH_COMMAND utiliser par référentiel.

core.sshCommand:

Si cette variable est définie, git fetch et git Push utiliseront la commande spécifiée au lieu de ssh lorsqu’ils devront se connecter à un système distant.
La commande se présente sous la même forme que la variable d'environnement GIT_SSH_COMMAND et est remplacée lorsque la variable d'environnement est définie.

Cela signifie que le git clone peut être:

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

Comme indiqué ici: https://superuser.com/a/912281/607049

Vous pouvez le configurer par référent:

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

Je suis allé avec la variable d’environnement GIT_SSH . Voici mon wrapper, similaire à celui de Joe Block d’en haut, mais qui gère n’importe quelle quantité d’arguments.

Fichier ~/gitwrap.sh

#!/bin/bash
ssh -i ~/.ssh/gitkey_rsa "$@"

Ensuite, dans mon .bashrc, ajoutez ce qui suit:

export GIT_SSH=~/gitwrap.sh
30
Jamie

Meilleure idée d’ajouter cet hôte ou cette adresse IP au fichier .ssh/config comme suit:

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

Lorsque vous devez vous connecter à github avec une requête normale (git pull Origin master), définir l'hôte sur * dans ~/.ssh/config fonctionnait pour moi, tout autre hôte (par exemple, "github" ou "gb") ne fonctionnait pas.

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

Beaucoup de ces solutions semblaient alléchantes. Cependant, j’ai trouvé l’approche générique git-wrapping-script sur le lien suivant comme la plus utile:

Comment spécifier un fichier de clé ssh avec la commande git

Le fait est qu'il n'y a pas de commande git comme celle-ci:

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

La solution d'Alvin consiste à utiliser un script bash-wrapper bien défini qui comble cette lacune:

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

Où git.sh est:

#!/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 \$@" > /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 "$@"

Je peux vérifier que cela résout un problème que je rencontrais avec la reconnaissance des utilisateurs et des clés pour un dépôt distant de bitbucket avec git remote update, git pull et git clone; tout cela fonctionne maintenant correctement dans un script de travail cron qui, autrement, rencontrait des problèmes pour naviguer dans le shell limité. J'ai également pu appeler ce script à partir de R et toujours résoudre le même problème cron execute .__ (par exemple, system("bash git.sh -i ~/.ssh/thatuserkey.pem pull")).

Non pas que R soit identique à Ruby, mais si R peut le faire ... O :-)

7
Paul McMurdie

Si aucune des solutions proposées ne vous convient et que vous avez créé plusieurs clés ssh, mais que vous ne pouvez toujours pas effectuer des tâches simples, telles que

git pull

puis en supposant que vous avez deux fichiers de clé ssh comme 

id_rsa
id_rsa_other_key

puis à l’intérieur du dépôt git avec lequel vous vous débattez (cd), essayez:

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

et assurez-vous également que votre nom d'utilisateur et votre identifiant par défaut github sont corrects en:

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

Voir https://Gist.github.com/jexchan/2351996 pour plus d'informations.

4
cgnorthcutt

GIT_SSH_COMMAND = "ssh -i/chemin/vers/git-privé-clé-d'accès" git clone $ git_repo

3
carlsborg

si vous avez un répertoire sur votre chemin où vous souhaitez signer avec un fichier d'identification donné, vous pouvez spécifier d'utiliser un fichier d'identification spécifique via le fichier .ssh/config en définissant la ControlPath e.g .:

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

Ensuite, ssh utilisera le fichier d'identité spécifié lors de l'exécution de commandes git sous le chemin de travail donné.

3
cristobal

Le truc pour moi était d’utiliser git @ hostname au lieu de http: // hostname

2
AmazingTurtle

Dans Windows avec Git Bash, vous pouvez utiliser les éléments suivants pour ajouter un référentiel ssh-agent bash -c 'ssh-add "key-address"; git remote add Origin "rep-address"' Par exemple: ssh-agent bash -c 'ssh-add /d/test/PrivateKey.ppk; git remote add Origin [email protected]:test/test.git' Quelle clé privée se trouve dans le lecteur D, test de dossier de l'ordinateur. De même, si vous souhaitez cloner un référentiel, vous pouvez modifier git remote add Origin avec git clone.

Après avoir entré ceci dans Git Bash, il vous demandera un mot de passe!

Sachez que la clé privée openssh et la clé privée PuTTY sont différentes!

Si vous avez créé vos clés avec puttygen, vous devez convertir votre clé privée en openssh!

2
Peyman Mahdavi

Vous pouvez utiliser la variable d'environnement GIT_SSH. Mais vous devrez envelopper ssh et les options dans un script shell.

Voir le manuel git: man git dans votre commande Shell.

2
rudimeier

Voici le hack de clé ssh que j'ai trouvé en trouvant une solution à ce problème:

Par exemple, vous avez 2 jeux de clés différents:

key1, key1.pub, key2, key2.pub

Conservez ces clés dans votre répertoire .ssh

Maintenant, dans votre fichier alias .bashrc ou .bash_profile, ajoutez ces commandes

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'

Voila! Vous avez un raccourci pour changer de clé quand vous le voulez!

J'espère que cela fonctionne pour toi. 

1
penduDev

pour le gitlabRSAAuthentication yes 

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

doc est ici

1
Alupotha

Vous devez créer un fichier ~/.ssh/config comme ci-dessous

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

permission comme ci-dessous

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

Ajoutez votre clé publique dans votre git (cat ~/.ssh/id_rsa_pub [ou nom simillar])

puis git clone comme ci-dessous

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

Le problème est que vous avez différents référentiels distants sur le même hôte (par exemple github.com) et que vous souhaitez interagir avec eux à l’aide de différentes clés ssh (c.-à-d. Différents comptes GitHub).

Pour pouvoir faire ça:

1) Commencez par déclarer vos différentes clés dans le fichier ~/.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

En faisant cela, vous associez la deuxième clé à un nouveau nom convivial "XXX" pour github.com.

2) Ensuite, vous devez modifier l’origine distante de votre référentiel particulier, afin qu’il utilise le nom convivial que vous venez de définir.

Accédez au dossier de votre référentiel local dans une invite de commande et affichez l'origine d'origine à distance:

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

Puis changez Origine avec:

>git remote set-url Origin git@XXX:myuser/myrepo.git
>git remote -v
Origin  git@XXX:myuser/myrepo.git (fetch)
Origin  git@XXX:myuser/myrepo.git (Push)

Maintenant, vous pouvez pousser, récupérer ... avec la bonne touche automatiquement.

0
rodo

Si le numéro de port SSH n'est pas 22 (valeur par défaut), ajoutez Port xx dans ~/.ssh/config

Dans mon cas (synologie),

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

Puis clonez en utilisant le titre de l'hôte dans config. ("ma_synologie". pour éviter le "*" de @chopstik) 

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

J'utilise zsh et différentes clés sont chargées automatiquement dans le ssh-agent de mon shell zsh à d'autres fins (accès aux serveurs distants, par exemple) sur mon ordinateur portable. J'ai modifié la réponse de @ Nick et je l'utilise pour l'un de mes dépôts qui doit être rafraîchi souvent. (Dans ce cas, c’est ma dotfiles pour laquelle je veux la même et la dernière version sur toutes mes machines, où que je sois.)

bash -c 'eval `ssh-agent`; ssh-add /home/myname/.dotfiles/gitread; ssh-add -L; cd /home/myname/.dotfiles && git pull; kill $SSH_AGENT_PID'
  • Générer un agent ssh
  • Ajouter une clé en lecture seule à l'agent
  • Changer de répertoire sur mon dépôt Git
  • Si cd au repo dir est réussi, extrait du repo distant
  • Tuer ssh-agent engendré. (Je ne voudrais pas que beaucoup d’agents s’attardent.)
0
sdkks

Si vous êtes comme moi, vous pouvez:

  • Gardez vos clés ssh organisées

  • Gardez vos commandes Git Clone simples

  • Traitez un nombre quelconque de clés pour un nombre quelconque de référentiels.

  • Réduisez la maintenance de votre clé ssh.

Je garde mes clés dans mon répertoire ~/.ssh/keys.

Je préfère la convention à la configuration.

Je pense que le code est la loi; plus c'est simple, mieux c'est.

ETAPE 1 - Créer un alias

Ajoutez cet alias à votre shell: alias git-clone='GIT_SSH=ssh_wrapper git clone'

STEP 2 - Créer un script

Ajoutez ce script ssh_wrapper à votre 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}" "$@"

EXEMPLES

Utilisez la clé github.com/l3x:

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

L'exemple suivant utilise également la clé github.com/l3x (par défaut):

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

Utilisez la clé bitbucket.org/lsheehan:

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

REMARQUES

Changez le SSH_KEY par défaut dans le script ssh_wrapper pour ce que vous utilisez la plupart du temps. De cette façon, vous n’avez pas besoin d’utiliser la variable KEY la plupart du temps.

Vous pensez peut-être: "Hé! Il se passe beaucoup de choses avec un alias, un script et un répertoire de clés", mais pour moi c'est une convention. Presque tous mes postes de travail (et les serveurs d'ailleurs) sont configurés de la même manière.

Mon but ici est de simplifier les commandes que j'exécute régulièrement.

Mes conventions, par exemple les scripts Bash, les alias, etc., créent un environnement cohérent et m'aident à garder les choses simples.

KISS et les noms comptent.

Pour plus d’astuces de conception, consultez Chapitre 4 SOLID Design in Go de mon livre: https://www.Amazon.com/Learning-Functional-Programming-Lex-Sheehan-ebook/ dp/B0725B8MYW

J'espère que cela pourra aider. - Lex

0
l3x