Puis-je spécifier plusieurs utilisateurs pour moi-même dans .gitconfig?

Dans mon ~/.gitconfig, je liste mon adresse e-mail personnelle sous [user], car c'est ce que je veux utiliser pour les dépôts Github.

Mais, j'ai récemment commencé à utiliser git pour le travail aussi. Le dépôt git de mon entreprise me permet de m'engager, mais lorsqu'il envoie des annonces de nouveaux changesets, il dit qu'ils viennent d'Anonymous car il ne reconnaît pas l'adresse e-mail dans ma .gitconfig- du moins, c'est ma théorie.

Est-il possible de spécifier plusieurs [user]définitions dans .gitconfig? Ou existe-t-il un autre moyen de remplacer la valeur .gitconfigpar défaut pour un certain répertoire? Dans mon cas, je vérifie tout le code de travail ~/worksrc/- existe-t-il un moyen de spécifier un .gitconfigpour uniquement ce répertoire (et ses sous-répertoires)?

Vous pouvez configurer un référentiel individuel pour utiliser un utilisateur / une adresse e-mail spécifique qui remplace la configuration globale. Depuis la racine du référentiel, exécutez

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

tandis que l'utilisateur / email par défaut est configuré dans votre ~ / .gitconfig

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

Depuis git 2.13 , il est possible de résoudre ce problème en utilisant les inclusions conditionnelles nouvellement introduites .

Un exemple:

Configuration globale ~ / .gitconfig

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

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

Configuration spécifique au travail ~ / work / .gitconfig

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

Ou vous pouvez ajouter les informations suivantes dans votre .git/configfichier local

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

Commutateur de comptes github à une commande

Cette solution prend la forme d'un seul alias git. Une fois exécuté, l'utilisateur actuel du projet sera rattaché à un autre compte

Générer des clés ssh

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'

Liez-les à vos comptes GitHub / Bitbucket

1. copier la clé publique par défaut pbcopy < ~/.ssh/id_rsa.pub
2. connectez-vous à votre compte GitHub
3. collez la clé dans la add SSH keypage github
4. copier une autre clé publique pbcopy < ~/.ssh/id_rsa_pro.pub
5. répétez et adaptez les étapes 2 à 4 pour tous les autres comptes

Étape 1. Commutation automatique des touches ssh.

Nous pouvons configurer sshpour envoyer une utilisation une clé de cryptage spécifique en fonction de la host. La bonne chose est que vous pouvez avoir plusieurs alias pour le même hostname.

Voir cet exemple de ~/.ssh/configfichier:

# 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

configuration à distance git

Vous pouvez maintenant utiliser ces alias dans les télécommandes git en changeant git@github.compar git@github_pro.

Vous pouvez soit modifier vos télécommandes de projets existants (en utilisant quelque chose comme git remote set-url origin git@github_pro:foo/bar.git), soit les adapter directement lors du clonage.

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

en utilisant un alias, il devient:

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

Étape 2. Changer git user.email

Les paramètres de configuration de Git peuvent être globaux ou par projet. Dans notre cas, nous voulons un paramètre par projet. Il est très facile de le changer:

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

Bien que cela soit facile, cela prend beaucoup de temps aux développeurs que nous sommes. Nous pouvons écrire un alias git très simple pour cela.

Nous allons l'ajouter au ~/.gitconfigfichier.

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

...

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

Ensuite, tout ce que nous avons à faire est git setpromailde faire changer notre email pour ce projet uniquement.

Étape 3. Un commutateur de commande s'il vous plaît?!

Ne serait-il pas agréable de passer d'un compte par défaut à un compte spécifié avec une seule commande sans paramètre? C'est certainement possible. Cette commande comportera deux étapes:

• changer les télécommandes du projet en cours aux alias choisis
• modifier la configuration actuelle du projet user.email

Nous avons déjà une solution à commande unique pour la deuxième étape, mais la première est beaucoup plus difficile. Changement d'hôte distant à une commande

Voici la solution sous la forme d'une autre commande d'alias git à ajouter à votre ~/.gitconfig:

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

Cela permet de changer toutes les télécommandes d'un hôte à un autre (l'alias). Voir l'exemple:

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

Combinez-les tous

Il ne nous reste plus qu'à combiner les deux commandes en une seule, c'est assez simple. Découvrez comment j'intègre également la commutation d'hôte bitbucket.

[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\"

Lien source - Tutoriel

Après m'être inspiré du billet de blog d' Orr Sella, j'ai écrit un crochet de pré-validation (résidant en ~/.git/templates/hooks) qui définirait des noms d'utilisateur et des adresses e-mail spécifiques en fonction des informations contenues dans un référentiel local ./.git/config:

Vous devez placer le chemin d'accès au répertoire du modèle dans votre ~/.gitconfig:

[init]
    templatedir = ~/.git/templates

Ensuite, chacun git initou git clonerécupérera ce crochet et appliquera les données utilisateur lors du prochain git commit. Si vous souhaitez appliquer le hook à des dépôts déjà existants, exécutez simplement un git inità l'intérieur du référentiel afin de le réinitialiser.

Voici le crochet que j'ai trouvé (il a encore besoin d'être poli - les suggestions sont les bienvenues). Enregistrez-le sous

~/.git/templates/hooks/pre_commit

ou

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

et assurez-vous qu'il est exécutable: 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

ÉDITER:

J'ai donc réécrit le hook en hook et commande en Python. De plus, il est également possible d'appeler le script en tant que commande Git ( git passport). Il est également possible de définir un nombre arbitraire d'ID dans un configfile ( ~/.gitpassport) qui peuvent être sélectionnés à l'invite. Vous pouvez trouver le projet sur github.com: git-passport - Une commande Git et un hook écrits en Python pour gérer plusieurs comptes Git / identités d'utilisateurs .

Si vous ne souhaitez pas avoir d'adresse e-mail par défaut ( les liens d'adresse e-mail vers un utilisateur github ), vous pouvez configurer que vous souhaitez être invité. La façon dont vous pouvez le faire dépend de la version de git que vous utilisez, voir ci-dessous.

L'inconvénient (prévu) est que vous devez configurer votre adresse e-mail (et votre nom) une fois pour chaque référentiel. Donc, vous ne pouvez pas oublier de le faire.

Version <2.7.0

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

dans votre configuration globale, ~/.gitconfigcomme indiqué dans un commentaire de Dan Aloni dans le blog d'Orr Sella . Lorsque vous essayez de faire le premier commit dans un dépôt, git échoue avec le joli message:

*** 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)')

Le nom est tiré de la configuration globale lorsque l'adresse e-mail est définie localement (le message n'est pas parfaitement précis).

2.7.0 ≤ Version <2.8.0

Le comportement dans les versions <2.7.0 n'était pas prévu et corrigé avec 2.7.0. Vous pouvez toujours utiliser un hook de pré-validation comme décrit dans le blog d'Orr Sella . Cette solution fonctionne également pour d'autres versions, mais les autres solutions pas pour cette version.

Version ≥ 2.8.0

Dan Aloni a ajouté une option pour obtenir ce comportement (voir les notes de version ). Utilisez-le avec:

[user]
    useConfigOnly = true

Pour le faire fonctionner, vous ne pouvez pas donner un nom ou une adresse e-mail dans la configuration globale. Ensuite, au premier commit, vous obtenez un message d'erreur

fatal: user.useConfigOnly set but no name given

Le message n'est donc pas très instructif, mais puisque vous définissez l'option explicitement, vous devez savoir quoi faire. Contrairement à la solution des versions <2.7.0, vous devez toujours définir le nom et l'e-mail manuellement.

Avec les inclusions conditionnelles dans Git 2.13, il est désormais possible de faire coexister plusieurs utilisateurs / e-mails sur une seule machine avec peu de travail.

user.gitconfiga mon nom et mon adresse e-mail. work-user.gitconfiga mon nom de travail et mon e-mail. Les deux fichiers sont au ~chemin.

Mon nom / e-mail personnel s'applique donc par défaut. Pour c:/work/dir, mon nom de travail / e-mail est appliqué. Pour c:/work/github/dir, mon nom / e-mail personnel est appliqué. Cela fonctionne lorsque le dernier paramètre est appliqué.

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

gitdirest sensible à la casse et gitdir/ine respecte pas la casse.

"gitdir/i:github/"appliquerait l'inclusion conditionnelle pour tout répertoire avec githubdans son chemin.

Une autre option pour se familiariser gitavec plusieurs noms / e-mails consiste à créer un alias gitet à utiliser l' -cindicateur pour remplacer la configuration globale et spécifique au référentiel.

Par exemple, en définissant un alias:

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

Pour voir si cela fonctionne, tapez simplement git config user.email:

$ git config user.email
name@example.com

Au lieu d'un alias, vous pouvez également mettre un gitexécutable personnalisé dans votre $PATH.

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

Un avantage de ces méthodes par rapport à un référentiel spécifique .git/configest qu'elles s'appliquent à chaque gitréférentiel lorsque le gitprogramme personnalisé est actif. De cette façon, vous pouvez facilement basculer entre les utilisateurs / noms sans modifier aucune configuration (partagée).

les alias git (et les sections dans les configurations git) à la rescousse!

ajoutez un alias (depuis la ligne de commande):

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

puis, définissez, par exemple

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

et dans un référentiel nouveau ou cloné, vous pouvez exécuter cette commande:

git identity github

Cette solution est automatique, mais l' utilisateur désenclencher et e - mail dans votre globale ~/.gitconfiget la mise user.useConfigOnlyà truecontraindrait git pour vous rappeler de les définir manuellement dans chaque nouveau ou cloné repo.

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

Voici les étapes complètes après avoir lu de nombreuses réponses ici

Comment configurer les paramètres de plusieurs clés SSH pour différents comptes Github

Vous voudrez peut-être commencer à vérifier vos clés actuellement enregistrées

$ ssh-add -l

Si vous décidez de supprimer toutes les clés en cache avant ( facultatif, faites attention à ce sujet )

$ ssh-add -D

Ensuite, vous pouvez créer une clé pub / priv ssh liée à chaque e-mail / compte que vous souhaitez / devez utiliser

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

Après avoir exécuté ces commandes, les fichiers suivants seront créés

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

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

Assurez-vous que l' agent d'authentification est en cours d'exécution

$ eval `ssh-agent -s`

Ajoutez les clés générées comme suit (à partir du dossier ~ / .ssh)

$ ssh-add id_rsa_work
$ ssh-add id_rsa_pers

Vous pouvez maintenant vérifier à nouveau vos clés enregistrées

$ ssh-add -l

Vous devez maintenant ajouter les clés publiques générées à vos clés d'accès au serveur github / bickbuket

Clonez chacun des référentiels dans différents dossiers

Accédez au dossier dans lequel le travail de l'utilisateur fonctionnera et exécutez-le

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

Juste pour voir ce que cela fait vérifier le contenu du ".git / config"

Accédez au dossier dans lequel l'utilisateur pers travaillera et exécutez ce

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

Juste pour voir ce que cela fait vérifier le contenu du ".git / config"

Après tout cela, vous pourrez valider votre code personnel et professionnel en basculant simplement entre ces deux dossiers

Dans le cas où vous utilisez Git Bash et devez générer des clés ssh sous Windows, procédez comme suit:

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

Il existe une solution simple qui semble bien fonctionner pour éviter les erreurs.

Supprimez simplement la [user]section de votre ~/.gitconfig, ce qui vous empêchera de faire des commits sans définir user.namepour chaque référentiel.

Dans votre ~/.bashrc, ajoutez quelques alias simples pour l'utilisateur et l'e-mail:

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'

Cette réponse est partiellement inspirée du message de @Saucier, mais je cherchais un moyen automatisé de définir user.nameet user.emailsur une base par rapport, basé sur la télécommande, qui était un peu plus léger que le paquet git-passeport qu'il a développé . H / t également à @John pour le paramètre useConfigOnly. Voici ma solution:

.gitconfig changements:

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

crochet post-paiement qui doit être enregistré dans le chemin suivant ~/.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

J'utilise des informations d'identification différentes pour github et gitlab, mais ces références dans le code ci-dessus peuvent être remplacées ou augmentées par n'importe quel service que vous utilisez. Afin que le hook post-paiement définisse automatiquement le nom d'utilisateur et l'adresse e-mail localement pour un dépôt après une vérification, assurez-vous que le nom du service apparaît dans l'URL distante, ajoutez-le au tableau des services dans le post-checkoutscript et créez une section pour celui-ci dans votre .gitconfigqui contient votre nom d'utilisateur et votre adresse e-mail pour ce service.

Si aucun des noms de service n'apparaît dans l'URL distante ou si le dépôt n'a pas de télécommande, le nom d'utilisateur et l'e-mail ne seront pas définis localement. Dans ces cas, le user.useConfigOnlyparamètre sera en jeu, ce qui ne vous permettra pas d'effectuer des validations tant que le nom d'utilisateur et l'e-mail ne sont pas définis au niveau du référentiel, et invitera l'utilisateur à configurer ces informations.

GIT_AUTHOR_EMAIL + local .bashrc

.bashrc_local: ne suivez pas ce fichier, placez-le uniquement sur votre ordinateur de travail:

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

.bashrc: suivre ce fichier, le rendre identique sur les ordinateurs professionnels et personnels:

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

J'utilise https://github.com/technicalpickles/homesick pour synchroniser mes fichiers dot.

Si seulement gitconfig acceptait les variables d'environnement: Expansion des variables shell dans git config

Environnement Windows

Ceci peut être modifié à partir de Git Extensions --> Settings --> Global Settings, si vous l'avez installé dans vos systèmes.

gitextensions-dernière-version

Cliquez avec le bouton droit sur un dossier / répertoire dans l'environnement Windows pour accéder à ces paramètres.

Mise à jour : comment changer / maintenir plusieurs paramètres dans la version 2.49

C'est peut-être un simple hack, mais c'est utile. Générez simplement 2 clés ssh comme ci-dessous.

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]-----+

De la même façon, créez-en un de plus pour le personnel. Donc, vous avez 2 clés SSH, votre travail et votre entreprise. Copiez work.pub, work, personal.pub, personal dans ~ / .ssh / Directory.

Créez ensuite un script shell avec les lignes suivantes et nommez-le comme crev.sh (Company Reverse) avec le contenu suivant.

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

De la même manière, créez-en un de plus appelé prev.sh (Personal Reverse) avec le contenu suivant.

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

dans ~ / .bashrc ajoutez des alias pour ces scripts comme ci-dessous

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

Chaque fois que vous voulez utiliser la société, faites simplement crev, et si vous voulez utiliser personnel, prev :-p.

Ajoutez ces clés ssh à vos comptes GitHub. Assurez-vous que id_rsa n'a pas été généré précédemment, car ces scripts remplaceront id_rsa. Si vous avez déjà généré id_rsa, utilisez-le pour l'un des comptes. Copiez-les comme personnelles et ignorez la génération de clés personnelles.

J'ai créé une fonction bash qui gère cela. Voici le repo Github .

Pour l'enregistrement:

# 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'

Ajoutez simplement ceci à votre ~ / .bash_profile pour basculer entre les clés par défaut de github.com

# 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"

Vous pouvez également utiliser git commit --author "Your Name <your@email.com>"au moment de faire une validation dans un référentiel où vous souhaitez valider en tant qu'utilisateur différent.

Quelque chose comme la réponse de Rob W , mais autorisant différentes clés ssh différentes, et fonctionne avec les anciennes versions de git (qui n'ont pas par exemple une configuration core.sshCommand).

J'ai créé le fichier ~/bin/git_poweruser, avec la permission exécutable, et dans le CHEMIN:

#!/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" $@

Chaque fois que je veux engager ou pousser quelque chose en tant que "Utilisateur avancé", j'utilise à la git_poweruserplace de git. Il devrait fonctionner sur n'importe quel répertoire et ne nécessite pas de modifications dans, .gitconfigou .ssh/configdu moins pas dans le mien.

Bien que la plupart des questions aient en quelque sorte répondu à l'OP, je n'ai eu qu'à passer par moi-même et sans même googler, j'ai pu trouver la solution la plus rapide et la plus simple. Voici des étapes simples:

• copie existante .gitconfgde votre autre référentiel
• coller dans votre référentiel nouvellement ajouté
• modifier les valeurs du .gitconfigfichier, telles que le nom, l'e-mail et le nom d'utilisateur [user] name = John email = john@email.net username = john133
• ajouter un nom de fichier à la .gitignoreliste, pour vous assurer de ne pas valider le .gitconfigfichier dans votre référentiel de travail