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


1110

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?


6
Voir également cette question dans SuperUser .
Flimm

28
Je me demande pourquoi c'est si inhabituel que Git n'a pas d' -ioption comme le sshfait.
Nick T

29
Avec git 2.10 (Q3 2016), vous avez également une nouvelle configuration: git config core.sshCommand 'ssh -i private_key_file'. Voir ma réponse ci
VonC

3
À mon avis, la réponse HeyWatchThis devrait être la réponse acceptée car elle permet à toutes les commandes git d'être exécutées normalement après la configuration plutôt que d'avoir à créer un sous-shell pour chaque commande git comme l'exige la réponse acceptée actuelle.
gloriphobia

Réponses:


801

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.


5
Mais cela ajoutera la clé de manière permanente en tant que clé SSH acceptée, non? Je veux éviter cela afin que theuser2 ne puisse pas jouer avec les projets de theuser. Il s'agit d'une application Web, il n'est donc pas pratique d'utiliser différents utilisateurs d'OS, ce qui aurait été la meilleure option.
Christoffer

28
Non, lorsque git est terminé, ssh-agent se termine et la clé est oubliée.
Martin c.Löwis

6
cette commande ne fonctionne pas sur windows git bash. Il indique une erreur de syntaxe près du jeton inattendu 'ssh-add'
Mohit

116
La ligne de commande fixe (pour Windows ou Linux) serait quelque chose comme:ssh-agent bash -c 'ssh-add sshkey; git clone url'
orip

4
La ssh-agent $(..)syntaxe ne fonctionne pas pour moi et je ne sais pas comment cela est censé fonctionner: (ba) sh devrait d'abord exécuter les commandes à l'intérieur $(..), puis exécuter ssh-agent avec la sortie en paramètre.
Johannes 'fish' Ziemke

1201

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


17
J'ai trouvé que lorsque vous spécifiez plusieurs clés à l'aide de .ssh / config, vous devez utiliser le nom de l'hôte ami dans la ligne "Host" dans le cadre de la commande "git remote add". Si la ligne est "Host stg", vous devez utiliser git remote add <someName> user @ stg: /path_to_git_repo.git ". Si vous utilisez le nom de serveur exact comme user@myserver.com: /path_to_git_repo.git, le fichier de configuration n'est pas sélectionné par git. Par conséquent, il ne sélectionne pas correctement le fichier de clé privée. J'ai essayé cela en poussant le même contenu vers github et heroku et ne fonctionne que lorsque vous donnez un nom convivial dans "git remote add"
Gopinath MR

2
Je n'étais pas sûr de l'hôte de github. J'ai trouvé ce lien: gist.github.com/jexchan/2351996 .
Karsten

1
Jetez un oeil ici si vous voulez avoir quelques fichiers clés pour quelques dépôts git
e271p314

1
Vous pouvez utiliser Host remote.server.comet continuer d'utiliser l'URL d'origine
MauganRa

5
Cela a fonctionné pour moi après deux changements. Si le fichier de configuration est nouveau, n'oubliez pas de le faire chmod 600 ~/.ssh/config(voir ici ). Et si vous utilisez GitHub, remplacez Host gitservpar Host github.com, omettez Hostname remote.server.comet ajoutez remote avec git remote add origin git@github.com:user_name/repo_name.git.
miguelmorin

481

À 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

3
Je reçois cannot run ssh -i /home/vagrant/.ssh/git: No such file or directorybien qu'il existe 444 Nov 16 18:12 /home/vagrant/.ssh/gitdels -l /home/vagrant/.ssh/git
ted

3
@ted: chmod 400 /home/vagrant/.ssh/git
Yash

8
Solution agréable et facile. Je suggère de créer un alias si vous devez souvent le faire.
Lasse Meyer

5
N'oubliez pas chmod 400 <path-to-private-key-file>. Sinon, la commande git peut échouer sans message d'erreur spécial ...
Eonil

5
Il serait bon que cette réponse inclue également -o IdentitiesOnly=yespour s'assurer que la clé spécifiée avec -iest utilisée (par opposition à une clé de l'agent SSH).
robinst

423

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

Host github.com
  IdentityFile ~/.ssh/github_rsa

30
Vous avez également besoin de l' IdentitiesOnlyoption.
Flimm

4
@EnzeChi vous pouvez avoir plusieurs comptes GitHub en manipulant les télécommandes: git remote add ssh://personal/org/proj.git && git remote add ssh://corporate/org/proj.git. Ensuite, votre configuration ressemble àHost personal HostName github.com ... Host corporate HostName github.com
Emory

@EnzeChi Je fais quelque chose de similaire pour que j'utilise 2 clés ssh différentes - une pour aller chercher et l'autre pour pousser. L'extraction n'a pas de phrase secrète. La poussée fait.
emory

144

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

4
Très bonne solution si vous avez plus d'un compte sur le même domaine, que les autres solutions ne gèrent pas bien
Beka

1
Belle solution. Vous pouvez également simplifier cela avec> GIT_SSH = my_git_ssh_wrapper; git clone git@github.com: TheUser / TheProject.git
Shiva

2
Cette solution couvre également les situations où vous souhaitez utiliser git depuis un compte sans répertoire personnel.
piotrekkr

Fantastique. Vous pouvez également utiliser cette méthode pour des serveurs privés:GIT_SSH="git_wrapper" git clone ssh://user@server/path/to/project"
ton

1
C'est la seule façon qui a fonctionné pour moi dans un environnement cygwin
ChatterOne

113

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"

@Flimm dates de sortie: calendar.google.com/calendar/…
VonC

Il a été rendu public.
Flimm

4
Travaux. Les gens devraient considérer cela comme la meilleure réponse. Une fois émis, il peut être intéressant de différencier le fichier .git / config avec une version préalablement copiée dans / tmp. Une nouvelle entrée a été créée: sshCommand = ... Pour ce que ça vaut, j'ai utilisé 'git config core.sshCommand "ssh -i $ HOME / .ssh / privatekeyfile".
WeakPointer

1
@Spanky Vous pouvez faire la commande en ligne git -c core.sshCommand="ssh -i private_key_file" clone host:repo.gitsuivie de l'ensemble de configurationgit config core.sshCommand 'ssh -i private_key_file'
dav_i

1
C'est définitivement la meilleure réponse!
Wagner Patriota

111

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.


3
Je vous ai déçu parce que tout ce que vous dites est déjà couvert dans les réponses ci-dessus, et à mes yeux, encore plus clairement. Par exemple, pourquoi définissez-vous exactement l'utilisateur comme e dandv et utilisateur de travail, respectivement?
hroptatyr

2
Vous avez répondu à une question de 4 ans sans nouvelles informations et vous prétendez que votre réponse est "la meilleure façon". De plus, vous avez downvoté et incité d'autres utilisateurs à supprimer leur réponse ... juste pour obtenir votre réponse.
rudimeier

@hroptatyr: J'ai utilisé dandvet workuserpour soutenir mon exemple, "par exemple un compte GitHub personnel et un compte professionnel". dandvest mon nom d'utilisateur GitHub.
Dan Dascalescu

12
Je pense que c'est une meilleure réponse que celle de @ thamster, ne serait-ce que parce qu'elle explique les alias d'hôte.
David Moles

2
J'aime cette réponse. Cependant, pour moi, cela ne fonctionne que si j'ajoute IdentitiesOnly yesà mon fichier de configuration ssh.
winni2k

75

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

1
Que fait -F /dev/null-il? Pour autant que je puisse voir, cela changera configFile par ~/.ssh/configdéfaut, mais pourquoi cela est-il souhaité? Pour garantir une commande en bac à sable?
Dominic

3
linuxcommand.org/man_pages/ssh1.html , ne spécifie aucun fichier de configuration, donc quand git exécutera ssh, aucun fichier de configuration ne sera transmis (en fait, c'est une sorte de mode sandbox, ignorez simplement les options par défaut de la configuration utilisateur) Le fil d'origine dans le superutilisateur a plus d'informations sur -F
David

1
Celui que je cherchais. Merci!
lostcitizen

Solution AAAAA + pour travailler en environnement kuber. Merci!
Cobra vs Ninja

1
Salut Savez-vous comment propager cela à un sous-module?
Arka Prava Basu

38

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.


1
C'est la réponse la plus "correcte" dans mon esprit, où vous organisez les connexions et les clés dans votre fichier de configuration ssh qui sont les meilleures pratiques et supportables à long terme.
jamescampbell

D'autres solutions semblent être des solutions de contournement, cela utilise une grande fonctionnalité prise en charge par l'outil.
Craig.C

Génial, exactement ce que je cherchais, merci !!
magikMaker

37
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

Celui-ci a fonctionné pour moi.
mohammed_ayaz

36

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)

1
C'est utile, mais vous fait utiliser la clé de dépôt pour toutes les interactions avec ce nom d'hôte. S'il existe d'autres repos sur le même serveur qui nécessitent des clés différentes, il est préférable d'utiliser un wrapper et de dire à git de l'utiliser avec GIT_SSH.
Joe Block

11
Ce n'est pas nécessairement vrai. J'utilise plusieurs clés pour Github - une pour le travail et une pour mon compte personnel. Vous n'avez pas besoin de mettre un nom de domaine pour "Host". Vous pouvez mettre tout type d'alias que vous souhaitez. Par exemple, j'utilise gh-home et gh-work comme nom d'hôte et lorsque je clone, j'utilise, par exemple, git clone git@gh-work:repo/project.git Dans mon ~ / .ssh / config, j'ai deux sections qui utilisent toutes les deux github.com pour HostName. Ils ont juste différents IdentityFile et Host
blockloop

@ brettof86 cette stratégie fonctionne pour la plupart, mais que faites-vous lorsqu'un référentiel que vous consultez dépend d'une gemme qui est également hébergée sur github? La référence au dépôt github dans le Gemfile ne contiendra pas votre "alias", à moins que vous ne vouliez casser des choses pour d'autres développeurs sur le projet ...
ktec

@ brettof86 J'ai également deux comptes Github différents (travail, domicile), mais je ne parviens pas à faire fonctionner l'exemple pour moi. Pouvez-vous publier un échantillon de deux?
Climbs_lika_Spyder

@Climbs_lika_Spyder voici ce qu'il y a dans mon ~/.ssh/config pastebin.com/8rYn7yCi
blockloop

32

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

J'ai mis cela sur .bashrc. Mais lorsque je me connecte à l'instance openshift, il ne semble pas l'appeler. Suis-je en train de manquer quelque chose?
Jigar Shah

Il échoue avec une erreur pour moi .. il ne parvient pas à trouver l'événement de script bien qu'il soit là .. pas sûr de ce qui se passe ... erreur: ne peut pas exécuter /tmp/gitwrap.sh: aucun fichier ou répertoire de ce type
ap1234

Si vous rencontrez une erreur "Aucun fichier ou répertoire", mettez le chemin complet de gitwrap.sh , par exemple/home/ubuntu/gitwrap.sh
Tahir Akhtar

vous voudrez peut-être ajouter -o StrictHostKeyChecking=noà la commande ssh
dan-man

12

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.


Notez que si vous obtenez Could not open a connection to your authentication agent., essayez $ eval `ssh-agent -s`et réessayez.
cgnorthcutt

1
Pour ceux qui sont perdus, l' ssh-addastuce de commande a fonctionné pour moi. Ajoutez la clé d'identité à la liste de ceux qui sont essayés lorsque ssh s'authentifie. Cela a bien fonctionné pour moi!
Ben Cartwright

Pourquoi pensez-vous qu'il importe dans quel répertoire vous exécutez ssh-add?
tripleee

@BenCartwright Parce que vous modifiez les paramètres locaux, pas les paramètres globaux. Cette approche modifie l' .gitintérieur du référentiel et non le programme git globalement. Vous pouvez utiliser --globalpour définir le nom d'utilisateur et l'e-mail globaux.
cgnorthcutt

11

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

Autant laisser de côté toute la ligne "Host *".
lionello

1
Cela ne fonctionnait probablement pas, car il ne correspondait pas à votre URL distante. Si vous souhaitez utiliser Host my-host-alias, vous devez définir remote.origin.url=git@my-host-alias:[username]/[repo].git.
David Moles

11

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

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


1
Ça a l'air génial! Je vais tester cela et répondre.
BlueBird

3
En dehors de la syntaxe, comment est-ce mieux que GIT_SSH_COMMAND="ssh -i ~/.ssh/thatuserkey.pem" git clone clone thatuser@myserver.com:/git/repo.gitselon la réponse de Robert Jack Will ?
David Moles

6

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


J'ai découvert plus tard que vous pouvez également définir les propriétés ControlMaster autoet ControlPersist yes, de sorte que vous n'avez pas besoin de retaper le mot de passe à chaque fois. J'ai trouvé l'info dans cet article
cristobal

3

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

3

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 .


1
Merci beaucoup, j'ai passé tellement de temps à essayer de comprendre pourquoi git n'utilise pas la clé ssh. Je ne comprends pas pourquoi github donne l'URL https par défaut dans le bouton clone.
Chakradar Raju

2

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!


1

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.


1

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

1

pour le gitlab RSAAuthentication yes

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

le doc est ici


ne semble plus être mentionné sur le lien que vous avez fourni
rbennell


0

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

0

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



0

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


0

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

-1

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.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.