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 git@github.com:TheUser/TheProject.git -key "/home/christoffer/ssh_keys/theuser"

Ou encore mieux (en Ruby):

with_key("/home/christoffer/ssh_keys/theuser") do
  sh("git clone git@github.com: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?

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

ssh-agent bash -c 'ssh-add /somewhere/yourkey; git clone git@github.com:user/project.git'

si vous préférez les sous-coquilles, vous pouvez essayer ce qui suit (bien qu'il soit plus fragile):

ssh-agent $(ssh-add /somewhere/yourkey; git clone git@github.com:user/project.git)

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

Alternativement, le réglage HOMEpeut également faire l'affaire, à condition que vous souhaitiez configurer un répertoire qui ne contient qu'un .sshrépertoire as HOME; il peut contenir soit un fichier identity.pub, soit un paramètre de fichier de configuration IdentityFile.

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

Au lieu de cela, j'élabore sur la mention de @Martin c. Löwis de la définition d'un configfichier pour SSH.

SSH recherchera le ~/.ssh/configfichier de l'utilisateur . J'ai le mien configuré comme:

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 yesest requis pour empêcher le comportement par défaut 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_rsaqui sera essayé AVANT votre ~/.ssh/id_rsa.githubsans cette option.

Références

• Meilleure façon d'utiliser plusieurs clés privées SSH sur un seul client
• Comment pourrais-je arrêter ssh offrant une mauvaise clé

À partir de 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

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

Host github.com
  IdentityFile ~/.ssh/github_rsa

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 git@github.com:TheUser/TheProject.git

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

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

Une nouvelle variable de configuration core.sshCommanda été ajoutée pour spécifier la valeur GIT_SSH_COMMANDà utiliser par référentiel.

core.sshCommand:

Si cette variable est définie git fetchet git pushutilisera la commande spécifiée au lieu du sshmoment où ils doivent se connecter à un système distant.
La commande se présente sous la même forme que la GIT_SSH_COMMANDvariable d'environnement et est remplacée lorsque la variable d'environnement est définie.

Cela signifie que le git clonepeut être:

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

Vous pouvez même le définir pour une seule commande:

git -c core.sshCommand="ssh -i private_key_file" clone host:repo.git

Il est plus facile que la fixation d' un GIT_SSH_COMMANDvariable d'environnement, qui, sous Windows, comme indiqué par Mátyás Kuti-Kreszács , serait

set "GIT_SSH_COMMAND=ssh -i private_key_file"

Pour résumer les réponses et les commentaires , la meilleure façon de configurer git pour utiliser différents fichiers clés et ensuite de l'oublier, qui prend également en charge différents utilisateurs pour le même hôte (par exemple, un compte GitHub personnel et un compte professionnel), qui fonctionne sous Windows est également de modifier ~/.ssh/config(ou c:\Users\<your user>\.ssh\config) et de 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 git clonecommande standard .

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

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

Vous pouvez le configurer par repo:

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

Le problème est lorsque 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 en utilisant différentes clés ssh (c'est-à-dire différents comptes GitHub).

Pour pouvoir faire ça:

1. Vous devez d'abord déclarer vos différentes clés dans le ~/.ssh/configfichier.

   # 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

   Ce faisant, 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 à votre dossier de référentiel local dans une invite de commande et affichez l'origine distante actuelle:

   >git remote -v
   origin  git@github.com:myuser/myrepo.git (fetch)
   origin  git@github.com:myuser/myrepo.git (push)

   Puis changez d'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.

GIT_SSH_COMMAND="ssh -i /path/to/git-private-access-key" git clone $git_repo

ou

export GIT_SSH_COMMAND="ssh -i /path/to/git-private-access-key"
git clone REPO
git push

Meilleure idée d'ajouter cet hôte ou cette ip au .ssh/configfichier comme ceci:

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)

Je suis allé avec la variable d'environnement GIT_SSH. Voici mon wrapper, similaire à celui de Joe Block ci-dessus, mais 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

Si aucune des autres solutions ne fonctionne pour vous et que vous avez créé plusieurs clés ssh, mais que vous ne pouvez toujours pas faire des choses simples comme

git pull

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

id_rsa
id_rsa_other_key

puis à l'intérieur du dépôt git, essayez:

# Run these commands INSIDE your git directory
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 ID utilisateur par défaut github sont corrects en:

# Run these commands INSIDE your git directory
git config user.name "Mona Lisa"
git config user.email "mona.lisa@email.com"

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

Lorsque vous devez vous connecter à github avec une demande normale ( git pull origin master), réglage de l'hôte comme *dans ~/.ssh/configtravaillé pour moi, tout autre hôte ( par exemple, « GitHub » ou « Go ») ne fonctionnait pas.

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

Beaucoup de ces solutions semblaient séduisantes. Cependant, j'ai trouvé l'approche générique git-wrapping-script sur le lien suivant pour être la plus utile:

Comment spécifier un fichier de clé ssh avec la gitcommande

Le fait étant qu'il n'y a pas de gitcommande telle que la suivante:

git -i ~/.ssh/thatuserkey.pem clone thatuser@myserver.com:/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 thatuser@myserver.com:/git/repo.git

Où git.shest:

#!/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 cette résolu un problème que j'avais avec l' utilisateur / reconnaissance clé pour une prise en pension de bitbucket à distance avec git remote update, git pullet git clone; qui fonctionnent désormais très bien dans un cronscript de travail qui avait autrement du mal à naviguer dans le shell limité. J'ai également pu appeler ce script à partir de R et toujours résoudre le même cronproblème d'exécution (par exemplesystem("bash git.sh -i ~/.ssh/thatuserkey.pem pull") ).

Non pas que R soit le même que Ruby, mais si R peut le faire ... O :-)

si vous avez un répertoire sur votre chemin où vous souhaitez vous connecter 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 par ControlPathexemple:

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 des commandes git sous le chemin de travail donné.

Vous devez créer un ~ / .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

autorisation 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://blahblah@blah.com/userid/test.git

Beaucoup de bonnes réponses, mais certaines supposent des connaissances administratives préalables.

Je pense qu'il est important de souligner explicitement que si vous avez démarré votre projet en clonant l'URL Web - https://github.com/<user-name>/<project-name>.git
vous devez vous assurer que la url valeur sous [remote "origin"]dans le a .git/config été remplacée par l'URL SSH (voir le bloc de code ci-dessous).

En plus de cela, assurez-vous d'ajouter le sshCommmandcomme mentionné ci-dessous:

user@workstation:~/workspace/project-name/.git$ cat config
[core]
    repositoryformatversion = 0
    filemode = true
    bare = false
    logallrefupdates = true
    sshCommand = ssh -i ~/location-of/.ssh/private_key -F /dev/null <--Check that this command exist
[remote "origin"]
    url = git@github.com:<user-name>/<project-name>.git  <-- Make sure its the SSH URL and not the WEB URL
    fetch = +refs/heads/*:refs/remotes/origin/*
[branch "master"]
    remote = origin
    merge = refs/heads/master

En savoir plus ici .

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 git@git.test.com:test/test.git'quelle clé privée se trouve dans le lecteur D, test de dossier de l'ordinateur. De plus, si vous souhaitez cloner un référentiel, vous pouvez changer git remote add originavec git clone.

Après avoir entré cela dans Git Bash, il vous demandera une phrase secrète!

Soyez conscient 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!

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

Voir le manuel de git: man gitdans votre shell de commande.

J'utilise zshet différentes clés sont chargées ssh-agentautomatiquement sur mon shell zsh à d'autres fins (c'est-à-dire l'accès aux serveurs distants) 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 actualisé souvent. (Dans ce cas, c'est la mienne dotfilesdont je veux la même et la dernière version sur toutes mes machines, où que je travaille.)

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 pour mon dépôt git
• Si cd le repo dir réussit, tirez du repo distant
• Tuez le ssh-agent engendré. (Je ne voudrais pas que beaucoup d'agents s'attardent.)

pour le gitlab RSAAuthentication yes

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

le doc est ici

Pour que la variable d'environnement GIT_SSH_COMMAND fonctionne sous Windows au lieu de:

set GIT_SSH_COMMAND="ssh -i private_key_file"

Utilisation:

set "GIT_SSH_COMMAND=ssh -i private_key_file"

La citation doit être comme

set "variable=value" 

Certains backgorund: https://stackoverflow.com/a/34402887/10671021

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

Dans mon cas (synologie),

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

Ensuite, clonez en utilisant le titre d'hôte dans la configuration. ("my_synology". pour éviter "@" de @chopstik)

git clone my_synology:path/to/repo.git

Si vous êtes comme moi, vous pouvez:

• Gardez vos clés SSH organisées

• Gardez vos commandes de git clone simples

• Manipulez n'importe quel nombre de clés pour n'importe quel nombre de référentiels.

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

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

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

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

ÉTAPE 1 - Créer un alias

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

ÉTAPE 2 - Créer un script

Ajoutez ce script ssh_wrapper à votre CHEMIN :

#!/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 git@bitbucket.org:dave_andersen/exchange.git

REMARQUES

Remplacez SSH_KEY par défaut dans le script ssh_wrapper par 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 pouvez penser, "Hé! Cela se passe beaucoup avec un alias, un script et un répertoire de clés", mais pour moi c'est la convention. Presque tous mes postes de travail (et serveurs d'ailleurs) sont configurés de manière similaire.

Mon objectif 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 de conseils de conception, consultez le 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

Vous pouvez essayer le package sshmulti npm pour conserver plusieurs clés ssh.

Le problème avec cette méthode est, au moins lors de l'exécution par bash.exe sur Windows, qu'elle créera à chaque fois un nouveau processus qui restera dormant.

ssh-agent bash -c 'ssh-add /somewhere/yourkey; git clone git@github.com:user/project.git'

Si vous voulez utiliser cela pour le repo syncig dans les délais, vous devez ajouter "&& ssh-agent -k" à la fin.

Quelque chose comme:

ssh-agent bash -c 'ssh-add C:/Users/user/.ssh/your_key; git -C "C:\Path\to\your\repo" pull && ssh-agent -k' 

ssh-agent -k va tuer le processus une fois terminé.

J'avais juste besoin d'ajouter la clé puis d'exécuter à nouveau le clone git.

ssh-add ~/.ssh/id_rsa_mynewkey
git clone git@bitbucket.org:mycompany/myrepo.git

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 .sshrépertoire

Maintenant, dans votre fichier .bashrcou .bash_profilealias, 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 souhaitez!

J'espère que cela fonctionne pour toi.