Kann ich in .gitconfig mehrere Benutzer für mich angeben?

In meiner ~/.gitconfigListe liste ich meine persönliche E-Mail-Adresse unter auf [user], da ich diese für Github-Repos verwenden möchte.

Aber ich habe vor kurzem auch angefangen, Git für die Arbeit zu verwenden. Das Git-Repo meines Unternehmens ermöglicht mir das Festschreiben, aber wenn es Ankündigungen neuer Änderungssätze sendet, heißt es, dass diese von Anonym stammen, weil die E-Mail-Adresse in meinem Unternehmen nicht erkannt wird .gitconfig- zumindest ist das meine Theorie.

Ist es möglich, mehrere [user]Definitionen in anzugeben .gitconfig? Oder gibt es eine andere Möglichkeit, die Standardeinstellung .gitconfigfür ein bestimmtes Verzeichnis zu überschreiben ? In meinem Fall checke ich den gesamten Arbeitscode aus. Gibt ~/worksrc/es eine Möglichkeit, .gitconfignur für dieses Verzeichnis (und seine Unterverzeichnisse) ein anzugeben ?

Sie können ein einzelnes Repo so konfigurieren, dass eine bestimmte Benutzer- / E-Mail-Adresse verwendet wird, die die globale Konfiguration überschreibt. Führen Sie von der Wurzel des Repos aus

git config user.name "Your Name Here"
git config user.email your@email.com

Der Standardbenutzer / die Standard-E-Mail-Adresse ist in Ihrer ~ / .gitconfig konfiguriert

git config --global user.name "Your Name Here"
git config --global user.email your@email.com

Seit Git 2.13 ist es möglich, dies mit neu eingeführten bedingten Includes zu lösen .

Ein Beispiel:

Globale Konfiguration ~ / .gitconfig

[user]
    name = John Doe
    email = john@doe.tld

[includeIf "gitdir:~/work/"]
    path = ~/work/.gitconfig

Arbeitsspezifische Konfiguration ~ / work / .gitconfig

[user]
    email = john.doe@company.tld

Oder Sie können folgende Informationen in Ihre lokale .git/configDatei einfügen

[user]  
    name = Your Name
    email = your.email@gmail.com

Ein Befehl Github Accounts wechseln

Diese Lösung hat die Form eines einzelnen Git-Alias. Nach der Ausführung wird der aktuelle Projektbenutzer einem anderen Konto zugeordnet

Generieren Sie SSH-Schlüssel

ssh-keygen -t rsa -C "rinquin.arnaud@gmail.com" -f '/Users/arnaudrinquin/.ssh/id_rsa'

[...]

ssh-keygen -t rsa -C "arnaud.rinquin@wopata.com" -f '/Users/arnaudrinquin/.ssh/id_rsa_pro'

Verknüpfen Sie sie mit Ihren GitHub / Bitbucket-Konten

1. Kopieren Sie den öffentlichen Standardschlüssel pbcopy < ~/.ssh/id_rsa.pub
2. Melden Sie sich bei Ihrem GitHub-Konto an
3. add SSH keyFügen Sie den Schlüssel in die Github-Seite ein
4. Kopieren Sie einen anderen öffentlichen Schlüssel pbcopy < ~/.ssh/id_rsa_pro.pub
5. Wiederholen und passen Sie die Schritte 2 bis 4 für jedes andere Konto an

Schritt 1. Automatische Umschaltung der SSH-Taste.

Wir können konfigurieren ssh, um eine Verwendung eines bestimmten Verschlüsselungsschlüssels abhängig von der zu senden host. Das Schöne ist, dass Sie mehrere Aliase für dasselbe haben können hostname.

Siehe diese Beispieldatei ~/.ssh/config:

# Default GitHub
Host github.com
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_rsa

# Professional github alias
Host github_pro
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_rsa_pro

Git Remote-Konfiguration

Sie können nun diese Aliase in den git - Fernbedienungen verwenden , indem git@github.comdurch git@github_pro.

Sie können entweder Ihre vorhandenen Projektfernbedienungen ändern (mit etwas wie git remote set-url origin git@github_pro:foo/bar.git) oder sie direkt beim Klonen anpassen.

git clone git@github.com:ArnaudRinquin/atom-zentabs.git

Mit Alias ​​wird es:

git clone git@github_pro:ArnaudRinquin/atom-zentabs.git

Schritt 2. Ändern der git user.email

Die Git-Konfigurationseinstellungen können global oder pro Projekt sein. In unserem Fall möchten wir eine pro Projekt Einstellungen. Es ist sehr einfach, es zu ändern:

git config user.email 'arnaud.rinquin@wopata.com'

Das ist zwar einfach, aber für die Entwickler, die wir sind, dauert es viel zu lange. Wir können dafür einen sehr einfachen Git-Alias ​​schreiben.

Wir werden es der ~/.gitconfigDatei hinzufügen .

[user]
    name = Arnaud Rinquin
    email = rinquin.arnaud@gmail.com

...

[alias]
    setpromail = "config user.email 'arnaud.rinquin@wopata.com'"

Dann müssen wir nur git setpromailnoch unsere E-Mail-Adresse für dieses Projekt ändern.

Schritt 3. Ein Befehlsschalter bitte?!

Wäre es nicht schön, mit einem einzigen Befehl ohne Parameter von einem Standardkonto zu einem angegebenen Konto zu wechseln? Das ist definitiv möglich. Dieser Befehl besteht aus zwei Schritten:

• Ändern Sie die aktuellen Projektfernbedienungen in die ausgewählten Aliase
• Ändern Sie die aktuelle Projektbenutzer-E-Mail-Konfiguration

Wir haben bereits eine Ein-Befehl-Lösung für den zweiten Schritt, aber der erste ist viel schwieriger. Ein Befehl Remote Host ändern

Hier kommt die Lösung in Form eines weiteren Git-Alias-Befehls, den Sie zu Ihrem hinzufügen können ~/.gitconfig:

[alias]
  changeremotehost = !sh -c \"git remote -v | grep '$1.*fetch' | sed s/..fetch.// | sed s/$1/$2/ | xargs git remote set-url\"

Dies ermöglicht das Ändern aller Fernbedienungen von einem Host auf einen anderen (den Alias). Siehe das Beispiel:

$ > git remote -v
origin  git@github.com:ArnaudRinquin/arnaudrinquin.github.io.git (fetch)
origin  git@github.com:ArnaudRinquin/arnaudrinquin.github.io.git (push)

$ > git changeremotehost github.com github_pro

$ > git remote -v
origin  git@github_pro:ArnaudRinquin/arnaudrinquin.github.io.git (fetch)
origin  git@github_pro:ArnaudRinquin/arnaudrinquin.github.io.git (push)

Kombiniere sie alle

Wir müssen jetzt nur noch die beiden Befehle zu einem kombinieren, das ist ganz einfach. Sehen Sie, wie ich auch Bitbucket-Host-Switching integriere.

[alias]
  changeremotehost = !sh -c \"git remote -v | grep '$1.*fetch' | sed s/..fetch.// | sed s/$1/$2/ | xargs git remote set-url\"
  setpromail = "config user.email 'arnaud.rinquin@wopata.com'"
  gopro = !sh -c \"git changeremotehost github.com github_pro && git changeremotehost bitbucket.com bitbucket_pro && git setpromail\"

Quelllink-Tutorial

Nachdem ich mich von Orr Sellas Blog-Post inspirieren ließ, schrieb ich einen Pre-Commit-Hook (befindet sich in ~/.git/templates/hooks), in dem bestimmte Benutzernamen und E-Mail-Adressen basierend auf den Informationen in einem lokalen Repositorie festgelegt wurden ./.git/config:

Sie müssen den Pfad zum Vorlagenverzeichnis in Folgendes einfügen ~/.gitconfig:

[init]
    templatedir = ~/.git/templates

Dann nimmt jeder git initoder git clonediesen Haken auf und wendet die Benutzerdaten während des nächsten an git commit. Wenn Sie den Hook auf bereits vorhandene Repos anwenden möchten, führen Sie einfach ein git initInside im Repo aus, um es neu zu initialisieren.

Hier ist der Haken, den ich mir ausgedacht habe (er muss noch poliert werden - Vorschläge sind willkommen). Speichern Sie es entweder als

~/.git/templates/hooks/pre_commit

oder

~/.git/templates/hooks/post-checkout

und stellen Sie sicher, dass es ausführbar ist: chmod +x ./post-checkout || chmod +x ./pre_commit

#!/usr/bin/env bash

# -------- USER CONFIG
# Patterns to match a repo's "remote.origin.url" - beginning portion of the hostname
git_remotes[0]="Github"
git_remotes[1]="Gitlab"

# Adjust names and e-mail addresses
local_id_0[0]="my_name_0"
local_id_0[1]="my_email_0"

local_id_1[0]="my_name_1"
local_id_1[1]="my_email_1"

local_fallback_id[0]="${local_id_0[0]}"
local_fallback_id[1]="${local_id_0[1]}"


# -------- FUNCTIONS
setIdentity()
{
    local current_id local_id

    current_id[0]="$(git config --get --local user.name)"
    current_id[1]="$(git config --get --local user.email)"

    local_id=("$@")

    if [[ "${current_id[0]}" == "${local_id[0]}" &&
          "${current_id[1]}" == "${local_id[1]}" ]]; then
        printf " Local identity is:\n"
        printf "»  User: %s\n»  Mail: %s\n\n" "${current_id[@]}"
    else
        printf "»  User: %s\n»  Mail: %s\n\n" "${local_id[@]}"
        git config --local user.name "${local_id[0]}"
        git config --local user.email "${local_id[1]}"
    fi

    return 0
}

# -------- IMPLEMENTATION
current_remote_url="$(git config --get --local remote.origin.url)"

if [[ "$current_remote_url" ]]; then

    for service in "${git_remotes[@]}"; do

        # Disable case sensitivity for regex matching
        shopt -s nocasematch

        if [[ "$current_remote_url" =~ $service ]]; then
            case "$service" in

                "${git_remotes[0]}" )
                    printf "\n»» An Intermission\n»  %s repository found." "${git_remotes[0]}"
                    setIdentity "${local_id_0[@]}"
                    exit 0
                    ;;

                "${git_remotes[1]}" )
                    printf "\n»» An Intermission\n»  %s repository found." "${git_remotes[1]}"
                    setIdentity "${local_id_1[@]}"
                    exit 0
                    ;;

                * )
                    printf "\n»  pre-commit hook: unknown error\n» Quitting.\n"
                    exit 1
                    ;;

            esac
        fi
    done
else
    printf "\n»» An Intermission\n»  No remote repository set. Using local fallback identity:\n"
    printf "»  User: %s\n»  Mail: %s\n\n" "${local_fallback_id[@]}"

    # Get the user's attention for a second
    sleep 1

    git config --local user.name "${local_fallback_id[0]}"
    git config --local user.email "${local_fallback_id[1]}"
fi

exit 0

BEARBEITEN:

Also habe ich den Hook als Hook und Befehl in Python umgeschrieben. Zusätzlich ist es möglich, das Skript auch als Git-Befehl ( git passport) aufzurufen . Es ist auch möglich, eine beliebige Anzahl von IDs in einer Konfigurationsdatei ( ~/.gitpassport) zu definieren, die an einer Eingabeaufforderung ausgewählt werden können. Sie finden das Projekt unter github.com: git-passport - Ein in Python geschriebener Git-Befehl und -Hook zum Verwalten mehrerer Git-Konten / Benutzeridentitäten .

Wenn Sie keine Standard-E- Mail-Adresse haben möchten ( E-Mail-Adresslinks zu einem Github-Benutzer ), können Sie konfigurieren, dass Sie gefragt werden möchten. Wie Sie dies tun können, hängt von der verwendeten Git-Version ab (siehe unten).

Der (beabsichtigte) Nachteil ist, dass Sie Ihre E-Mail-Adresse (und Ihren Namen) einmal für jedes Repository konfigurieren müssen. Sie können es also nicht vergessen.

Version <2.7.0

[user]
    name = Your name
    email = "(none)"

in Ihrer globalen Konfiguration, ~/.gitconfigwie in einem Kommentar von Dan Aloni in Orr Sellas Blogbeitrag angegeben . Beim Versuch, das erste Commit in einem Repository durchzuführen, schlägt git mit der netten Nachricht fehl:

*** Please tell me who you are.

Run

  git config --global user.email "you@example.com"
  git config --global user.name "Your Name"

to set your account's default identity.
Omit --global to set the identity only in this repository.

fatal: unable to auto-detect email address (got '(none)')

Der Name wird aus der globalen Konfiguration übernommen, wenn die E-Mail-Adresse lokal festgelegt wird (die Nachricht ist nicht genau).

2.7.0 ≤ Version <2.8.0

Das Verhalten in Versionen <2.7.0 war nicht beabsichtigt und wurde mit 2.7.0 behoben. Sie können weiterhin einen Pre-Commit-Hook verwenden, wie in Orr Sellas Blog-Beitrag beschrieben . Diese Lösung funktioniert auch für andere Versionen, die anderen Lösungen jedoch nicht für diese Version.

Version ≥ 2.8.0

Dan Aloni hat eine Option hinzugefügt , um dieses Verhalten zu erreichen (siehe Versionshinweise ). Verwenden Sie es mit:

[user]
    useConfigOnly = true

Damit es funktioniert, dürfen Sie in der globalen Konfiguration keinen Namen oder keine E-Mail-Adresse angeben. Beim ersten Festschreiben wird dann eine Fehlermeldung angezeigt

fatal: user.useConfigOnly set but no name given

Die Nachricht ist also nicht sehr lehrreich, aber da Sie die Option explizit festlegen, sollten Sie wissen, was zu tun ist. Im Gegensatz zur Lösung von Versionen <2.7.0 müssen Sie Name und E-Mail immer manuell einstellen.

Mit bedingten Includes in Git 2.13 ist es jetzt möglich, mehrere Benutzer / E-Mails mit wenig Arbeit auf einem Computer nebeneinander zu haben.

user.gitconfighat meinen persönlichen Namen und meine E-Mail. work-user.gitconfighat meinen Arbeitsnamen und meine E-Mail. Beide Dateien befinden sich im ~Pfad.

Mein persönlicher Name / meine E-Mail-Adresse gilt also standardmäßig. Für c:/work/dir wird mein Arbeitsname / meine E-Mail-Adresse angewendet. Für c:/work/github/dir wird mein persönlicher Name / meine E-Mail-Adresse verwendet. Dies funktioniert, wenn die letzte Einstellung angewendet wird.

# ~/.gitconfig
[include]
    path = user.gitconfig
[includeIf "gitdir/i:c:/work/"]
    path = work-user.gitconfig
[includeIf "gitdir/i:c:/work/github/"]
    path = user.gitconfig

gitdirunterscheidet zwischen Groß- und Kleinschreibung und unterscheidet nicht zwischen gitdir/iGroß- und Kleinschreibung.

"gitdir/i:github/"würde das bedingte Include für jedes Verzeichnis mit githubin seinem Pfad anwenden .

Eine weitere Option, um gitmit mehreren Namen / E-Mails arbeiten zu können, ist das Aliasing gitund die Verwendung des -cFlags, um die globale und repository-spezifische Konfiguration zu überschreiben.

Zum Beispiel durch Definieren eines Alias:

alias git='/usr/bin/git -c user.name="Your name" -c user.email="name@example.com"'

Um zu sehen, ob es funktioniert, geben Sie einfach Folgendes ein git config user.email:

$ git config user.email
name@example.com

Anstelle eines Alias ​​können Sie auch eine benutzerdefinierte gitausführbare Datei in Ihr Verzeichnis einfügen $PATH.

#!/bin/sh
/usr/bin/git -c user.name="Your name" -c user.email="name@example.com" "$@"

Ein Vorteil dieser Methode gegenüber einer Repository-spezifischen Methode .git/configbesteht darin, dass sie für jedes gitRepository gilt, wenn das benutzerdefinierte gitProgramm aktiv ist. Auf diese Weise können Sie problemlos zwischen Benutzern / Namen wechseln, ohne eine (gemeinsam genutzte) Konfiguration zu ändern.

Git-Aliase (und Abschnitte in Git-Konfigurationen) zur Rettung!

Fügen Sie einen Alias ​​hinzu (über die Befehlszeile):

git config --global alias.identity '! git config user.name "$(git config user.$1.name)"; git config user.email "$(git config user.$1.email)"; :'

dann setzen Sie zum Beispiel

git config --global user.github.name "your github username"
git config --global user.github.email your@github.email

und in einem neuen oder geklonten Repo können Sie diesen Befehl ausführen:

git identity github

Diese Lösung ist nicht automatisch, aber das Deaktivieren von Benutzer und E-Mail in Ihrer globalen ~/.gitconfigund die Einstellung user.useConfigOnlyauf truewürde Git dazu zwingen, Sie daran zu erinnern, sie manuell in jedem neuen oder geklonten Repo festzulegen.

git config --global --unset user.name
git config --global --unset user.email
git config --global user.useConfigOnly true

Hier sind die vollständigen Schritte, nachdem Sie hier viele Antworten gelesen haben

So richten Sie Einstellungen für mehrere SSH-Schlüssel für verschiedene Github-Konten ein

Möglicherweise möchten Sie Ihre aktuell gespeicherten Schlüssel überprüfen

$ ssh-add -l

Wenn Sie zuvor alle zwischengespeicherten Schlüssel löschen möchten ( optional, vorsichtig )

$ ssh-add -D

Anschließend können Sie einen SSH-Pub / Priv-Schlüssel erstellen, der mit jeder E-Mail / jedem Konto verknüpft ist, die / das Sie verwenden möchten / müssen

$ cd ~/.ssh
$ ssh-keygen -t rsa -C "work@company.com" <-- save it as "id_rsa_work"
$ ssh-keygen -t rsa -C "pers@email.com" <-- save it as "id_rsa_pers"

Nachdem Sie diese Befehle ausgeführt haben, werden die folgenden Dateien erstellt

~/.ssh/id_rsa_work      
~/.ssh/id_rsa_work.pub

~/.ssh/id_rsa_pers
~/.ssh/id_rsa_pers.pub 

Stellen Sie sicher, dass der Authentifizierungsagent ausgeführt wird

$ eval `ssh-agent -s`

Fügen Sie die generierten Schlüssel wie folgt hinzu (aus dem Ordner ~ / .ssh).

$ ssh-add id_rsa_work
$ ssh-add id_rsa_pers

Jetzt können Sie Ihre gespeicherten Schlüssel erneut überprüfen

$ ssh-add -l

Jetzt müssen Sie die generierten öffentlichen Schlüssel zu Ihren Github / Bickbuket-Server-Zugriffsschlüsseln hinzufügen

Klonen Sie jedes der Repos in verschiedene Ordner

Gehen Sie zu dem Ordner , in dem der Benutzer Arbeit funktioniert , und führen Sie diese

$ git config user.name "Working Hard"
$ git config user.email "work@company.com" 

Nur um zu sehen, was dies bewirkt, überprüfen Sie den Inhalt der ".git / config"

Gehen Sie zu dem Ordner , in dem die Benutzer pers arbeiten und führen diese

$ git config user.name "Personal Account"
$ git config user.email "pers@email.com" 

Nur um zu sehen, was dies bewirkt, überprüfen Sie den Inhalt der ".git / config"

Nach all dem können Sie Ihren persönlichen Code und Ihren Arbeitscode festschreiben, indem Sie einfach zwischen diesen beiden Ordnern wechseln

Wenn Sie Git Bash verwenden und unter Windows SSH-Schlüssel generieren müssen, gehen Sie folgendermaßen vor:

https://support.automaticsync.com/hc/en-us/articles/202357115-Generating-an-SSH-Key-on-Windows

Es gibt eine einfache Lösung, die gut funktioniert, um Fehler zu vermeiden.

Entfernen Sie einfach den [user]Abschnitt aus Ihrem ~/.gitconfig, wodurch Sie keine Commits vornehmen können, ohne user.namefür jedes Repository Einstellungen vorzunehmen.

~/.bashrcFügen Sie in Ihrem einige einfache Aliase für den Benutzer und die E-Mail hinzu:

alias ggmail='git config user.name "My Name";git config user.email me@gmail.com'
alias gwork='git config user.name "My Name";git config user.email me@work.job'

Diese Antwort ist teilweise von dem Beitrag von @Saucier inspiriert, aber ich suchte nach einer automatisierten Methode zum Einstellen user.nameund user.emailpro Repo, basierend auf der Fernbedienung, die etwas leichter war als das von ihm entwickelte Git-Pass-Paket . H / t auch an @John für die Einstellung useConfigOnly. Hier ist meine Lösung:

.gitconfig Änderungen:

[github]
    name = <github username>
    email = <github email>
[gitlab]
    name = <gitlab username>
    email = <gitlab email>
[init]
    templatedir = ~/.git-templates
[user]
    useConfigOnly = true

Post-Kasse Haken , der auf den folgenden Pfad gespeichert werden soll: ~/.git-templates/hooks/post-checkout:

#!/usr/bin/env bash

# make regex matching below case insensitive
shopt -s nocasematch

# values in the services array should have a corresponding section in
# .gitconfig where the 'name' and 'email' for that service are specified
remote_url="$( git config --get --local remote.origin.url )"
services=(
    'github'
    'gitlab'
)

set_local_user_config() {
    local service="${1}"
    local config="${2}"
    local service_config="$( git config --get ${service}.${config} )"
    local local_config="$( git config --get --local user.${config} )"

    if [[ "${local_config}" != "${service_config}" ]]; then
        git config --local "user.${config}" "${service_config}"
        echo "repo 'user.${config}' has been set to '${service_config}'"
    fi
}

# if remote_url doesn't contain the any of the values in the services
# array the user name and email will remain unset and the
# user.useConfigOnly = true setting in .gitconfig will prompt for those
# credentials and prevent commits until they are defined
for s in "${services[@]}"; do
    if [[ "${remote_url}" =~ "${s}" ]]; then
        set_local_user_config "${s}" 'name'
        set_local_user_config "${s}" 'email'
        break
    fi
done

Ich verwende unterschiedliche Anmeldeinformationen für github und gitlab, aber diese Verweise im obigen Code können durch jeden von Ihnen verwendeten Dienst ersetzt oder erweitert werden. Damit der Hook nach dem Auschecken den Benutzernamen und die E-Mail-Adresse für ein Repo nach dem Auschecken automatisch lokal festlegt, stellen Sie sicher, dass der Dienstname in der Remote-URL angezeigt wird, fügen Sie ihn dem Dienstarray im post-checkoutSkript hinzu und erstellen Sie einen Abschnitt dafür in Ihr .gitconfigenthält Ihren Benutzernamen und Ihre E-Mail-Adresse für diesen Dienst.

Wenn keiner der Dienstnamen in der Remote-URL angezeigt wird oder das Repo keine Remote hat, werden der Benutzername und die E-Mail-Adresse nicht lokal festgelegt. In diesen Fällen ist die user.useConfigOnlyEinstellung im Spiel, mit der Sie keine Commits vornehmen können, bis der Benutzername und die E-Mail-Adresse auf Repo-Ebene festgelegt sind, und der Benutzer aufgefordert wird, diese Informationen zu konfigurieren.

GIT_AUTHOR_EMAIL + lokal .bashrc

.bashrc_local: Verfolgen Sie diese Datei nicht, sondern legen Sie sie nur auf Ihrem Arbeitscomputer ab:

export GIT_AUTHOR_EMAIL='me@work.com'
export GIT_COMMITTER_EMAIL="$GIT_AUTHOR_EMAIL"

.bashrc: Verfolgen Sie diese Datei und machen Sie sie auf Arbeits- und Heimcomputern gleich:

F="$HOME/.bashrc_local"
if [ -r "$F" ]; then
    . "$F"
fi

Ich verwende https://github.com/technicalpickles/homesick, um meine Punktedateien zu synchronisieren.

Wenn nur gitconfig Umgebungsvariablen akzeptieren würde: Shell-Variablenerweiterung in git config

Windows-Umgebung

Zusätzlich kann dies geändert werden Git Extensions --> Settings --> Global Settings, wenn Sie es in Ihren Systemen installiert haben.

gitextensions-neueste-Veröffentlichung

Klicken Sie mit der rechten Maustaste auf einen Ordner / ein Verzeichnis in der Windows-Umgebung, um auf diese Einstellungen zuzugreifen.

Update : So wechseln / pflegen Sie mehrere Einstellungen in Version 2.49

Vielleicht ist es ein einfacher Hack, aber es ist nützlich. Generieren Sie einfach 2 SSH-Schlüssel wie unten.

Generating public/private rsa key pair.
Enter file in which to save the key (/Users/GowthamSai/.ssh/id_rsa): work
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in damsn.
Your public key has been saved in damsn.pub.
The key fingerprint is:
SHA256:CrsKDJWVVek5GTCqmq8/8RnwvAo1G6UOmQFbzddcoAY GowthamSai@Gowtham-MacBook-Air.local
The key's randomart image is:
+---[RSA 4096]----+
|. .oEo+=o+.      |
|.o o+o.o=        |
|o o o.o. +       |
| =.+ .  =        |
|= *+.   S.       |
|o*.++o .         |
|=.oo.+.          |
| +. +.           |
|.o=+.            |
+----[SHA256]-----+

Auf die gleiche Weise erstellen Sie eine weitere für persönliche. Sie haben also 2 SSH-Schlüssel, Arbeit und Gesellschaft. Kopieren Sie work.pub, work, personal.pub, personal in ~ / .ssh / Directory.

Erstellen Sie dann ein Shell-Skript mit den folgenden Zeilen und nennen Sie es crev.sh (Company Reverse) mit dem folgenden Inhalt.

cp ~/.ssh/work ~/.ssh/id_rsa
cp ~/.ssh/work.pub ~/.ssh/id_rsa.pub

Erstellen Sie auf die gleiche Weise eine weitere Datei namens prev.sh (Personal Reverse) mit dem folgenden Inhalt.

cp ~/.ssh/personal ~/.ssh/id_rsa
cp ~/.ssh/personal.pub ~/.ssh/id_rsa.pub

Fügen Sie in ~ / .bashrc Aliase für die folgenden Skripte hinzu

alias crev="sh ~/.ssh/crev.sh"
alias prev="sh ~/.ssh/prev.sh"
source ~/.bashrc

Wann immer Sie Gesellschaft verwenden möchten, machen Sie einfach Crev, und wenn Sie persönliche verwenden möchten, tun Sie prev :-p.

Fügen Sie diese SSH-Schlüssel Ihren GitHub-Konten hinzu. Stellen Sie sicher, dass id_rsa noch nicht generiert wurde, da diese Skripte id_rsa überschreiben. Wenn Sie bereits id_rsa generiert haben, verwenden Sie diese für eines der Konten. Kopieren Sie sie als persönlich und überspringen Sie die Generierung persönlicher Schlüssel.

Ich habe eine Bash-Funktion erstellt, die das erledigt. Hier ist das Github Repo .

Für die Aufzeichnung:

# Look for closest .gitconfig file in parent directories
# This file will be used as main .gitconfig file.
function __recursive_gitconfig_git {
    gitconfig_file=$(__recursive_gitconfig_closest)
    if [ "$gitconfig_file" != '' ]; then
        home="$(dirname $gitconfig_file)/"
        HOME=$home /usr/bin/git "$@"
    else
        /usr/bin/git "$@"
    fi
}

# Look for closest .gitconfig file in parents directories
function __recursive_gitconfig_closest {
    slashes=${PWD//[^\/]/}
    directory="$PWD"
    for (( n=${#slashes}; n>0; --n ))
    do
        test -e "$directory/.gitconfig" && echo "$directory/.gitconfig" && return 
        directory="$directory/.."
    done
}


alias git='__recursive_gitconfig_git'

Fügen Sie dies einfach zu Ihrem ~ / .bash_profile hinzu, um zwischen den Standardschlüsseln für github.com zu wechseln

# Git SSH keys swap
alias work_git="ssh-add -D  && ssh-add -K ~/.ssh/id_rsa_work"
alias personal_git="ssh-add -D && ssh-add -K ~/.ssh/id_rsa"

Sie können auch git commit --author "Your Name <your@email.com>"im Moment des Festschreibens in einem Repo verwenden, in dem Sie als anderer Benutzer festschreiben möchten.

So etwas wie Rob Ws Antwort , erlaubt aber einen anderen SSH-Schlüssel und funktioniert mit älteren Git-Versionen (die zB keine core.sshCommand-Konfiguration haben).

Ich habe die Datei ~/bin/git_powerusermit ausführbarer Berechtigung und im Pfad erstellt:

#!/bin/bash

TMPDIR=$(mktemp -d)
trap 'rm -rf "$TMPDIR"' EXIT

cat > $TMPDIR/ssh << 'EOF'
#!/bin/bash
ssh -i $HOME/.ssh/poweruserprivatekey $@
EOF

chmod +x $TMPDIR/ssh
export GIT_SSH=$TMPDIR/ssh

git -c user.name="Power User name" -c user.email="power@user.email" $@

Wann immer ich etwas als "Power User" festschreiben oder pushen möchte, verwende ich git_poweruseranstelle von git. Es sollte in jedem Verzeichnis funktionieren und erfordert keine Änderungen in .gitconfigoder .ssh/configzumindest nicht in meinem.

Obwohl die meisten Fragen das OP beantworteten, musste ich dies nur selbst durchgehen und ohne zu googeln konnte ich die schnellste und einfachste Lösung finden. Hier sind einfache Schritte:

• Kopie vorhanden .gitconfgvon Ihrem anderen Repo
• Einfügen in Ihr neu hinzugefügtes Repo
• Ändern Sie die Werte in der .gitconfigDatei, z. B. Name, E-Mail-Adresse und Benutzername [user] name = John email = john@email.net username = john133
• Fügen Sie der .gitignoreListe einen Dateinamen hinzu , um sicherzustellen, dass Sie keine .gitconfigDatei für Ihr Arbeits-Repo festschreiben