In ~/.ssh/config, voeg toe:

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

Als het configuratiebestand nieuw is, vergeet dan niet om chmod 600 ~/.ssh/config

te doen Nu kunt u git clone git@github.com:{ORG_NAME}/{REPO_NAME}.git

doen - Waar {ORG_NAME} de GitHub URI naam van uw GitHub gebruikersaccount (of organisatie-account) is. - Merk op dat er een dubbele punt : achter github.com staat in plaats van de schuine streep / - omdat dit geen URI is. - En {REPO_NAME} is de URI-naam van uw GitHub repo - Bijvoorbeeld, voor de Linux kernel zou dit git clone git@github.com:torvalds/linux.git zijn).

OPMERKING: Controleer op Linux en macOS of de rechten op uw IdentityFile 400 zijn. SSH zal, op een niet duidelijk expliciete manier, SSH-sleutels die te leesbaar zijn, afwijzen. Het zal er gewoon uitzien als een geloofsovertuiging. De oplossing, in dit geval, is:

chmod 400 ~/.ssh/id_rsa_github

Omgevingsvariabele GIT_SSH_COMMAND:

Vanaf Git versie 2.3.0 kunt u de omgevingsvariabele GIT_SSH_COMMAND als volgt gebruiken:

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

Merk op dat -i soms kan worden overschreven door uw configuratiebestand, in welk geval u SSH een leeg configuratiebestand moet geven, zoals dit:

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

Configuratie core.sshCommand:

Vanaf Git versie 2. 10.0 kunt u dit per repo of globaal configureren, zodat u de omgevingsvariabele niet meer hoeft in te stellen!

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

Er is geen direct manier om git te vertellen welke prive-sleutel te gebruiken, omdat het afhankelijk is van ssh voor repository authenticatie. Er zijn echter nog een paar manieren om je doel te bereiken:

Optie 1: ssh-agent

Je kunt ssh-agent gebruiken om je private sleutel tijdelijk te autoriseren.

Bijvoorbeeld:

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

Optie 2: GIT_SSH_COMMAND

Pas de ssh argumenten aan door de GIT_SSH_COMMAND omgevingsvariabele (Git 2.3.0+) te gebruiken.

bijvoorbeeld:

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

Je kan dit alles op één regel typen - negeer $ en laat de Er is **geen _direct_ manier** omgitte vertellen welke prive-sleutel te gebruiken, omdat het afhankelijk is vanssh` voor repository authenticatie. Er zijn echter nog een paar manieren om je doel te bereiken:

Optie 1: ssh-agent

Je kunt ssh-agent gebruiken om je private sleutel tijdelijk te autoriseren.

Bijvoorbeeld:

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

Optie 2: GIT_SSH_COMMAND

Pas de ssh argumenten aan door de GIT_SSH_COMMAND omgevingsvariabele (Git 2.3.0+) te gebruiken.

bijvoorbeeld:

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

Je kan dit alles op één regel typen - negeer $ en laat de weg.

Optie 3: GIT_SSH

Geef de ssh argumenten door gebruik te maken van de GIT_SSH omgevingsvariabele om alternatieve ssh binair te specificeren.

Bijvoorbeeld:

$ 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

Opmerking: De bovenstaande regels zijn shell (terminal) commandoregels die je in je terminal moet plakken. Ze maken een bestand aan met de naam ssh, maken het uitvoerbaar en voeren het (indirect) uit.

Opmerking: GIT_SSH is beschikbaar sinds v0.99.4 (2005).

Optie 4: ~/.ssh/config

Gebruik het ~/.ssh/config-bestand zoals voorgesteld in andere antwoorden om de locatie van uw privésleutel op te geven, bv.

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

Schrijf een script dat ssh aanroept met de argumenten die je wilt, en zet de bestandsnaam van het script in $GIT_SSH. Of zet je configuratie in ~/.ssh/config.

Gebruik aangepaste hostconfiguratie in ~/.ssh/config, zoals dit:

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

gebruik dan uw aangepaste hostnaam zoals dit:

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

Als u niet elke keer dat u git uitvoert omgevingsvariabelen wilt specificeren, geen ander wrapper-script wilt/kan niet ssh-agent(1) draaien, noch hiervoor een ander pakket wilt downloaden, gebruik dan het git-remote-ext(1) externe transport:

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

Ik beschouw deze oplossing als superieur omdat:

• Het is repository/remote specifiek
• Vermijd wrapperscript bloat
• Heb geen SSH-agent nodig – nuttig als je onbeheerde klonen/push/pulls wilt (e. g. in cron)
• Zeker, geen extern gereedschap nodig

Na mijn worsteling met $GIT_SSH wil ik graag delen wat voor mij heeft gewerkt.

Door middel van mijn voorbeelden ga ik ervan uit dat u uw prive-sleutel op/home/user/.ssh/jenkins

Fout te vermijden: GIT_SSH waarde bevat opties

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

of iets dergelijks zal falen, aangezien git zal proberen de waarde uit te voeren als een bestand. Om die reden moet je een script maken.

Werkend voorbeeld van $GIT_SSH script /home/user/gssh.sh

Het script wordt als volgt aangeroepen:

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

Voorbeeld van een script dat werkt zou kunnen lijken op:

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

Noteer de $* aan het eind, het is een belangrijk onderdeel ervan.

Nog veiliger alternatief, dat elk mogelijk conflict met iets in uw standaard configuratiebestand zou voorkomen (plus het expliciet vermelden van de te gebruiken poort) zou zijn:

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

In de veronderstelling dat het script in /home/user/gssh.sh staat, zult u dan:

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

en alles zal werken.

U kunt gewoon ssh-ident gebruiken in plaats van uw eigen wrapper te maken.

U kunt meer lezen op: https://github.com/ccontavalli/ssh-ident ](https://github.com/ccontavalli/ssh-ident)

Het laadt ssh-sleutels op verzoek wanneer het eerst nodig is, een keer, zelfs met meerdere inlogsessies, xterms of NFS gedeelde woningen.

Met een klein configuratiebestand kan het automatisch verschillende sleutels laden en ze gescheiden houden in verschillende agenten (voor het doorsturen van agenten), afhankelijk van wat u moet doen.

Ik had een klant die een aparte github account nodig had. Dus ik moest een aparte sleutel gebruiken voor dit ene project.

Mijn oplossing was om dit toe te voegen aan mijn .zshrc / .bashrc:

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

Wanneer ik git wil gebruiken voor dat project vervang ik “infogit” door git:

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

Voor mij is het makkelijker te onthouden.

Dus ik stel de GIT_SSH env variabele in op $HOME/bin/git-ssh.

Om mijn repo configuratie te ondersteunen is mijn ~/bin/git-ssh bestand als volgt:

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

Dan heb ik een globale git config instelling:

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

En binnen elke git repository kan ik gewoon een lokale ssh.identity git config waarde instellen:

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

Voila!

Als u voor elke identiteit een ander emailadres kunt hebben, wordt het nog eenvoudiger, omdat u gewoon uw sleutels naar uw emailadressen kunt noemen en dan de git config’s user.email de sleutelkeuze in een ~/bin/git-ssh als volgt kunt laten sturen:

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

Ik bouw op @shellholic en deze SO-draad met een paar teaks. Ik gebruik GitHub als voorbeeld en ga ervan uit dat u een privé-sleutel in ~/.ssh/github hebt (zie anders deze SO-draad ) en dat u de openbare sleutel aan uw GitHub-profiel hebt toegevoegd (zie anders GitHub’s hulp ).

Indien nodig, maak een nieuw SSH-configuratiebestand aan bij ~/.ssh/config en verander de rechten in 400

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

Voeg dit toe aan het ~/.ssh/config-bestand:

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

Als u al een externe instelling hebt, wilt u deze misschien verwijderen, anders wordt u misschien nog steeds gevraagd om uw gebruikersnaam en wachtwoord:

git remote rm origin

voeg dan een afstandsbediening toe aan het git archief, en let op de dubbele punt voor de gebruikersnaam:

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

en dan werken de git-commando’s normaal, e. g.:

git push origin master
git pull origin

@HeyWatchThis on this SO thread suggested adding IdentitiesOnly yes to prevent the SSH default behavior of sending the identity file matching the default filename for each protocol. Zie die thread voor meer informatie en referenties.

Mijn oplossing was dit:

maak een script:

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

dan wanneer je de var run moet veranderen:

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

Vergeet niet de extra punt!! dit maakt het script de omgevingen vars! —key en –port zijn optioneel.

Over het algemeen wilt u hiervoor ~/.ssh/config gebruiken. Koppel simpelweg de serveradressen met de sleutels die u voor hen wilt gebruiken als volgt:

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

Host * geeft elke server aan, dus ik gebruik het om ~/.ssh/id_rsa in te stellen als de standaard sleutel om te gebruiken.

Gebruik gewoon de ssh-agent en ssh-add commando’s.

# create an agent
ssh-agent

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

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

Na het uitvoeren van de bovenstaande commando’s kunt u beide toetsen tegelijk gebruiken. Typ gewoon

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

om uw opslagplaats te klonen.

U dient het bovenstaande commando uit te voeren na het herstarten van uw machine.

# 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

Hoewel de vraag er niet om vraagt, neem ik dit antwoord op voor iedereen die hetzelfde probleem specifiek voor gitlab .

De gitlab oplossing

heb ik geprobeerd met de omgevingsvariabelen aanpak, maar zelfs de git documentatie raadt het gebruik van ~/.ssh/config aan voor iets meer dan alleen het geval is. In mijn geval dring ik aan op een gitlab-server - en ik wilde dat doen als een specifieke gebruiker - die natuurlijk wordt gedefinieerd door de privésleutel tijdens authenticatie en niet door de gebruikersnaam git. Eenmaal geïmplementeerd voer ik eenvoudigweg het volgende uit:

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

Setup

Roep in mijn geval de locatie van uw privésleutel /myfolder/.ssh/my_gitlab_id_rsa op.

Voeg een vermelding toe in ~/.ssh/config:

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

Voeg de git-alias toe in ~/.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"

Als bonus voer ik mijn commits uit op dezelfde host als een specifieke gebruiker met deze git-alias :

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

Uitleg

Al het bovenstaande gaat ervan uit dat de relevante afstandsbediening origin is en dat de relevante tak momenteel is uitgecheckt. Ter referentie kwam ik een aantal zaken tegen die aangepakt moesten worden:

• De oplossing vereist het maken van een nieuwe afstandsbediening gitlab_as_me, en ik vond het niet leuk om de extra afstandsbediening te zien rondhangen in mijn stamboom dus ik verwijder deze als ik klaar ben met
• Om de afstandsbediening te maken, er is een noodzaak om de url van de afstandsbediening on the fly te genereren - in het geval van gitlab werd dit bereikt met een eenvoudige bash cut
• Bij het uitvoeren van een push naar gitlab_as_me moet je specifiek zijn over welke tak je duwt - Na het uitvoeren van de push moet je lokale origin-aanwijzer “geüpdatet” worden om overeen te komen met gitlab_as_me (de git pull origin $branch doet dit)

Wanneer u meerdere git-accounts heeft en u wilt verschillende ssh-toetsen

U moet dezelfde stap volgen voor het genereren van de ssh-toets, maar zorg ervoor dat u

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

het pad invoert dat u wilt opslaan(Ex: my-pc/Desktop/. ssh/ed25519)

Voeg de publieke sleutel toe aan uw gitlab Hoe voegt u ssh sleutel toe aan gitlab )

U moet de nieuwe ssh identiteit gebruiken met behulp van de onderstaande comand

ssh-add ~/my-pc/Desktop/.ssh/ed25519

Ik gebruik git versie 2.16 en ik heb geen enkel stuk script nodig, zelfs geen configuratie of gewijzigde commando’s.

• Gewoon mijn privé sleutel gekopieerd naar .ssh/id_rsa
• stel de rechten in op 600

en git leest automatisch naar sleutel. Ik vraag niets en het geeft geen foutmelding. Het werkt gewoon goed.

Als u verbinding moet maken met dezelfde host met verschillende toetsen dan kunt u dit bereiken door:

1. Configureer de ~/.ssh/config met verschillende Hosts maar dezelfde HostNames.
2. 3. Kloon je repo met de juiste host.

Voorbeeld:

~/.ssh/config “` Host work HostName bitbucket.org IdentityFile ~/.ssh/idrsawork User git

Host personal HostName bitbucket.org IdentityFile ~/.ssh/idrsapersonal User git ”`

dan in plaats van je repos te klonen zoals:

git clone git@bitbucket.org:username/my-work-project.git
git clone git@bitbucket.org:username/my-personal-project.git

je moet doen

git clone git@work:username/my-work-project.git
git clone git@personal:username/my-personal-project.git