Umgebungsvariable GIT_SSH_COMMAND:

Ab Git Version 2.3.0 können Sie die Umgebungsvariable GIT_SSH_COMMAND wie folgt verwenden:

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

Beachten Sie, dass -i manchmal von Ihrer Konfigurationsdatei überschrieben werden kann, in diesem Fall sollten Sie SSH eine leere Konfigurationsdatei wie folgt geben:

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

Konfiguration core.sshCommand:

Ab Git Version 2.10.0 können Sie dies pro Repo oder global konfigurieren, sodass Sie die Umgebungsvariable nicht mehr festlegen müssen!

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

Es gibt Nein direkt Weg sagen git die privaten Schlüssel zu benutzen, weil Sie sich auf ssh für das repository-Authentifizierung. Es gibt jedoch noch einige Möglichkeiten, Ihr Ziel zu erreichen:

Option 1: ssh-agent

Sie können ssh-agent verwenden, um Ihren privaten Schlüssel vorübergehend zu autorisieren.

Zum Beispiel:

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

Option 2: GIT_SSH_COMMAND

Übergeben Sie die ssh-Argumente mithilfe der Umgebungsvariablen GIT_SSH_COMMAND (Git 2.3.0+).

Für Beispiel:

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

_{Sie können dies alles in einer Zeile eingeben-ignore $ und lassen Sie die \.}

Option 3: GIT_SSH

Übergeben Sie die ssh-Argumente mithilfe der Umgebungsvariablen GIT_SSH, um die alternative ssh - Binärdatei anzugeben.

Zum Beispiel:

$ 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

_{Hinweis: Die obigen Zeilen sind Shell-Befehlszeilen (Terminal), die Sie in Ihr Terminal einfügen sollten. Sie erstellen eine Datei mit dem Namen ssh, machen Sie es ausführbar und (indirekt) führe es aus.}

^{Hinweis: GIT_SSH ist seit v0 verfügbar.99.4 (2005).}

Option 4: ~/.ssh/config

Verwenden Sie die Datei ~/.ssh/config wie in anderen Antworten vorgeschlagen, um den Speicherort Ihres privaten Schlüssels anzugeben, z. B.

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

Verwenden Sie die benutzerdefinierte Hostkonfiguration in ~/.ssh/config wie folgt:

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

Verwenden Sie dann Ihren benutzerdefinierten Hostnamen wie folgt:

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

Schreiben Sie ein Skript, das ssh mit den gewünschten Argumenten aufruft, und geben Sie den Dateinamen des Skripts in $GIT_SSH ein. Oder legen Sie einfach Ihre Konfiguration in ~/.ssh/config.

Wenn Sie bei jeder Ausführung von git keine Umgebungsvariablen angeben müssen, kein anderes Wrapper-Skript möchten, ssh-agent(1) nicht ausführen können oder ein anderes Paket nur dafür herunterladen möchten, verwenden Sie den externen Transport von git-remote-ext(1):

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

Ich halte diese Lösung für überlegen, weil:

• Es ist Repository / Remote-spezifisch
• Vermeiden Sie Wrapper script bloat
• Brauchen Sie den SSH-Agenten nicht-nützlich, wenn Sie unbeaufsichtigte Klone/Push/Pulls (z. in der cron)
• Definitiv kein externes tool nötig

Nach meinem Kampf mit $GIT_SSH möchte ich teilen, was für mich funktioniert hat.

In meinen Beispielen gehe ich davon aus, dass Sie Ihren privaten Schlüssel bei/home/user/.ssh/jenkins

Fehler zu vermeiden: GIT_SSH Wert enthält Optionen

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

Oder ähnliches schlägt fehl, da git versucht, den Wert als Datei auszuführen. Aus diesem Grund müssen Sie ein Skript erstellen.

Arbeitsbeispiel für $GIT_SSH Script /home/user/gssh.sh

Das Skript wird aufgerufen als folgt:

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

Beispielskript arbeiten könnte aussehen wie:

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

Beachten Sie die $* am Ende ist es ein wichtiger Teil davon.

Eine noch sicherere Alternative, die einen möglichen Konflikt mit irgendetwas in Ihrer Standardkonfigurationsdatei verhindern würde (plus explizite Erwähnung des zu verwendenden Ports) wäre:

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

Unter der Annahme, dass das Skript in /home/user/gssh.sh ist, werden Sie dann:

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

Und alles wird funktionieren.

Ich hatte einen Client, der ein separates Github-Konto benötigte. Also musste ich nur für dieses eine Projekt einen separaten Schlüssel verwenden.

Meine Lösung war, dies zu meinem hinzuzufügen .der zshrc / .bashrc:

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

Wenn ich git für dieses Projekt verwenden möchte, ersetze ich "infogit" durch git:

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

Für mich ist es leichter sich zu erinnern.

Also setze ich die env-Variable GIT_SSH auf $HOME/bin/git-ssh.

Um zu unterstützen, dass meine Repo-Konfiguration vorschreibt, welche SSH-Identität verwendet werden soll, lautet meine ~/bin/git-ssh Datei:

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

Dann habe ich eine globale Git-Konfigurationseinstellung:

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

Und in jedem Git-Repository kann ich einfach einen lokalen Git-Konfigurationswert ssh.identity festlegen:

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

Voila!

Wenn Sie für jede Identität eine andere E-Mail-Adresse haben können, wird es noch einfacher, da Sie Ihre Schlüssel einfach nach Ihrer E-Mail benennen können adressen und habe dann den Benutzer der git config.e-Mail-Laufwerk die Schlüsselauswahl in einem ~/bin/git-ssh wie folgt:

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

Sie können einfach ssh-ident verwenden, anstatt einen eigenen Wrapper zu erstellen.

Lesen Sie mehr unter: https://github.com/ccontavalli/ssh-ident

Es lädt SSH-Schlüssel bei Bedarf, wenn sie zum ersten Mal benötigt werden, einmal, auch bei mehreren Anmeldesitzungen, xterms oder NFS Shared Homes.

Mit einer winzigen Konfigurationsdatei können automatisch verschiedene Schlüssel geladen und in verschiedenen Agenten (für die Agentweiterleitung) getrennt werden, je nachdem, was Sie tun müssen.

Wenn Sie mit verschiedenen Schlüsseln eine Verbindung zum selben Host herstellen müssen, können Sie dies erreichen durch:

1. Konfigurieren Sie die ~/.ssh/config mit verschiedenen Hosts, aber gleichen HostNamen.
2. Klonen Sie Ihr Repo mit dem entsprechenden Host.

Beispiel:

~/.ssh/config

Host work
 HostName bitbucket.org
 IdentityFile ~/.ssh/id_rsa_work
 User git

Host personal
 HostName bitbucket.org
 IdentityFile ~/.ssh/id_rsa_personal
 User git

Dann statt Klonen Sie Ihre Repos wie:

git clone [email protected]:username/my-work-project.git
git clone [email protected]:username/my-personal-project.git

Sie müssen tun

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

Meine Lösung war folgende:

Erstelle ein Skript:

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

Wenn Sie dann den var-Lauf ändern müssen:

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

Vergiss den zusätzlichen Punkt nicht!! dadurch setzt das Skript die Umgebungsvariablen!! --Taste und-port sind optional.

Im Allgemeinen möchten Sie dafür ~/.ssh/config verwenden. Koppeln Sie Serveradressen einfach wie folgt mit den Schlüsseln, die Sie für sie verwenden möchten:

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

Host * bezeichnet einen beliebigen Server, daher verwende ich ihn, um ~/.ssh/id_rsa als Standardschlüssel festzulegen.

Ich baue auf @shell und diesen SO-Thread mit ein paar Teaks auf. Ich verwende GitHub als Beispiel und gehe davon aus, dass Sie einen privaten Schlüssel in ~/.ssh/github haben (andernfalls siehe this SO thread) und dass Sie den öffentlichen Schlüssel zu Ihrem GitHub-Profil hinzugefügt haben (andernfalls siehe GitHub ' s help).

Erstellen Sie bei Bedarf eine neue SSH-Konfigurationsdatei unter ~/.ssh/config und ändern Sie die Berechtigungen in 400

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

Fügen Sie dies der Datei ~/.ssh/config hinzu:

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

Wenn Sie bereits eine Fernbedienung eingerichtet haben, können Sie möglicherweise möchten Sie es löschen, andernfalls werden Sie möglicherweise weiterhin nach Benutzername und Kennwort gefragt:

git remote rm origin

Fügen Sie dann dem Git-Repository eine Fernbedienung hinzu und beachten Sie den Doppelpunkt vor dem Benutzernamen:

git remote add origin [email protected]:user_name/repo_name.git

Und dann funktionieren Git-Befehle normal, zB:

git push origin master
git pull origin 

@HeyWatchThis on Dieser SO-Thread schlug vor, IdentitiesOnly yes hinzuzufügen, um zu verhindern, dass das SSH-Standardverhalten beim Senden der Identitätsdatei mit dem Standarddateinamen für jedes Protokoll übereinstimmt. Siehe diesen Thread für weitere Informationen und Verweis.

Verwenden Sie einfach die Befehle ssh-agent und ssh-add.

# create an agent
ssh-agent

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

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

Nachdem Sie die obigen Befehle ausgeführt haben, können Sie beide Tasten gleichzeitig verwenden. Geben Sie einfach

git clone [email protected]:<yourname>/<your-repo>.git

Um Ihr Repository zu klonen.

Sie müssen den obigen Befehl ausführen, nachdem Sie Ihren Computer neu gestartet haben.

    # start :: how-to use different ssh identity files

    # create the company identity file
    ssh-keygen -t rsa -b 4096 -C "[email protected]"
    # 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 "[email protected]"
    # 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 [email protected]: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 <[email protected]>"
    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 [email protected]: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 <[email protected]>"
    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

Alle bisherigen Informationen (2020-01) sind nützlich, aber IMHO sind ein wenig chaotisch, und kein Beitrag fasst sie zu einer sauberen Lösung zusammen.

Also hier sind meine Lösungen. Wenn Sie mit Ihrer aktuellen Lösung Glück haben, können Sie diesen Beitrag ignorieren.

Insgesamt Prämisse:
Lösung für *nix-basiertes Betriebssystem. Getestet auf Debian-basiertem Betriebssystem, sollte aber auf anderen *nix-basierten Betriebssystemen funktionieren.

Allgemeine Voraussetzungen:

• Separaten Identität-Dateien (schlüssel) für verschiedene Hosts und / oder Benutzer verfügbar, z.B. generiert über ssh-keygen -f <filename> ...

Tore: 1: 0, 2: 0, 3: 0, 4: 0]}

• Verwenden Sie eine bestimmte Identitätsdatei (Schlüssel) pro Repository (optional: pro Host)
• Funktioniert mit jedem host: GitHub, GitLab, BitBucket, etc.
• Einfach zu bedienen und zu adoptieren
• Ziehe es vor, nicht mit URLs herumzuspielen und sie so zu verwenden, wie sie sind
• Verwenden Sie lieber die normale Konfiguration von git und ssh
• (nice-to-have) Arbeiten in der shell und gui werkzeuge
• (nett zu haben) Funktioniert mit jedem tool: git, ssh, svn, rsync, etc.

...
### >>> GitHub
## use: SSHGITUSER='<id>' git ...
## optional: git config --local core.sshCommand "SSHGITUSER='<id>' ssh"
Host github.com,gist.github.com
    IdentitiesOnly yes
    IdentityFile none
    User git

Match Host github.com,gist.github.com Exec "test ${SSHGITUSER:-_} = '1'"
    IdentityFile ~/.ssh/github-user1.key

Match Host github.com,gist.github.com Exec "test ${SSHGITUSER:-_} = 'gh2'"
    IdentityFile ~/.ssh/github-user2.key

Match Host github.com,gist.github.com Exec "test ${SSHGITUSER:-_} = 'dummy'"
    IdentityFile ~/.ssh/github-dummy-fake.key
### <<< GitHub
...
Host !github.com,!gist.github.com,*
    IdentityFile ~/.ssh/personal.key
...

SSHGITUSER='1' ssh -vT [email protected]

SSHGITUSER='1' git clone [email protected]:my-git-user-1/test-repo.git ~/work/test-repo

cd ~/work/test-repo
git config --local core.sshCommand "SSHGITUSER='1' ssh"
# Test: git fetch

...
### >>> GitHub
Host github.com,gist.github.com,*.github.com,*.gist.github.com,github.com-*,gist.github.com-*
        IdentitiesOnly yes
        IdentityFile none
        User git

Host 1.github.com,github.com-1
        IdentityFile ~/.ssh/github-user1.key
        Hostname github.com

Host 1.gist.github.com,gist.github.com-1
        IdentityFile ~/.ssh/github-user1.key
        Hostname gist.github.com

Host gh2.github.com,github.com-gh2
        IdentityFile ~/.ssh/github-user2.key
        Hostname github.com

Host gh2.gist.github.com,gist.github.com-gh2
        IdentityFile ~/.ssh/github-user2.key
        Hostname gist.github.com

### <<< GitHub

Host !github.com,!gist.github.com,*
   IdentityFile ~/.ssh/personal.key
...

Ich verwende git Version 2.16 und brauche kein einziges Skript, nicht einmal eine Konfiguration oder geänderte Befehle.

• Habe gerade meinen privaten Schlüssel kopiert .ssh/id_rsa
• Berechtigungen auf 600 setzen

Und git liest automatisch in die Taste. Ich frage nichts und es wird kein Fehler ausgegeben. Funktioniert einfach gut.

Während die Frage es nicht anfordert, füge ich diese Antwort für alle anderen hinzu, die das gleiche Problem nur speziell für gitlab lösen möchten.

Die gitlab Lösung

Ich habe versucht, die Umgebungsvariablen zu verwenden, aber selbst in der Git-Dokumentation wird empfohlen, ~/.ssh/config für mehr als den einfachen Fall zu verwenden. In meinem Fall drücke ich auf einen gitlab Server - und ich wollte dies als bestimmter Benutzer tun - was natürlich der Fall ist definiert durch den privaten Schlüssel während der Authentifizierung und nicht durch den Benutzernamen git. Einmal implementiert führe ich einfach Folgendes aus:

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

Einrichtung

Rufen Sie den Speicherort Ihres [[28]}privaten Schlüssels auf /myfolder/.ssh/my_gitlab_id_rsa in meinem Fall.

Fügen Sie einen Eintrag in ~/.ssh/config hinzu:

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

Fügen Sie die git-Alias 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 führe ich meine Commits auf demselben Host wie ein bestimmter Benutzer aus damit git-alias:

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

Erklärung

All dies setzt voraus, dass die relevante Remote origin ist und der relevante Zweig derzeit ausgecheckt ist. Als Referenz stieß ich auf mehrere Elemente, die angesprochen werden mussten:

• Die Lösung erfordert das Erstellen einer neuen Fernbedienung gitlab_as_me, und ich mochte es nicht, die zusätzliche Fernbedienung in meinem Protokollbaum zu sehen, also entferne ich sie, wenn ich fertig bin
• Um die Fernbedienung zu erstellen, muss generiert werden die remote-url-on-the-fly - in die Fall von gitlab erreicht wurde dies mit einem einfachen bash - Schnitt
• Wenn Sie einen Push auf gitlab_as_me ausführen, müssen Sie genau wissen, welchen Zweig Sie drücken
• Nach dem Ausführen des Push muss Ihr lokaler origin Zeiger "aktualisiert"werden, um gitlab_as_me (der git pull origin $branch tut dies)

Wenn Sie mehrere Git-Konten haben und einen anderen SSH-Schlüssel wünschen

Sie müssen denselben Schritt zum Generieren des ssh-Schlüssels ausführen, aber seien Sie sicher Sie

ssh-keygen -t ed25519 -C [email protected]

Geben Sie den Pfad ein, den Sie speichern möchten(z. B. my-pc/Desktop/.ssh/ed25519)

Hinweis: ed25519 ist der Ordnername

Fügen Sie den öffentlichen Schlüssel zu Ihrem gitlab hinzu (Hinzufügen des ssh-Schlüssels zu gitlab)

Sie müssen eine neue ssh-Identität mit dem folgenden comand

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