Plusieurs comptes Github sur le même ordinateur?

Essayer de travailler à la fois sur mes repos réels "de travail" et mes repos personnels sur git hub, depuis mon ordinateur.

Le compte de travail a été créé en premier et tout fonctionne parfaitement.

Cependant, mon compte personnel ne semble pas pouvoir pousser vers mon référentiel personnel, qui est configuré sous un autre compte / e-mail.

J'ai essayé de copier ma clé de travail sur mon compte personnel, mais cela génère une erreur, car bien sûr, une clé ne peut être attachée qu'à un seul compte.

Comment puis-je pousser / tirer vers et depuis les deux comptes, à partir de leurs informations d'identification github respectives?

Tout ce que vous devez faire est de configurer votre configuration SSH avec plusieurs paires de clés SSH.

• Ce lien est facile à suivre (merci Eric): http://code.tutsplus.com/tutorials/quick-tip-how-to-work-with-github-and-multiple-accounts--net-22574

• Génération de clés SSH (Win / msysgit) https://help.github.com/articles/generating-an-ssh-key/

De plus, si vous travaillez avec plusieurs référentiels en utilisant différents personnages, vous devez vous assurer que vos référentiels individuels ont les paramètres utilisateur remplacés en conséquence:

Définition du nom d'utilisateur, de l'e-mail et du jeton GitHub - Remplacement des paramètres pour les dépôts individuels https://help.github.com/articles/setting-your-commit-email-address-in-git/

J'espère que cela t'aides.

Remarque: Certains d'entre vous peuvent nécessiter l'utilisation de différents e-mails pour différents référentiels, à partir de git 2.13, vous pouvez définir l'e-mail sur une base de répertoire en modifiant le fichier de configuration global trouvé à: en ~/.gitconfigutilisant des conditions comme ceci:

[user]
    name = Pavan Kataria
    email = defaultemail@gmail.com

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

Et puis votre configuration spécifique au travail ~ / work / .gitconfig ressemblerait à ceci:

[user]
    email = pavan.kataria@company.tld

Merci @alexg de m'avoir informé de cela dans les commentaires.

Utilisez HTTPS:

changer l'URL à distance en https:

git remote set-url origin https://USERNAME@github.com/USERNAME/PROJECTNAME.git

et vous êtes prêt à partir:

git push

Pour vous assurer que les validations apparaissent comme effectuées par USERNAME, vous pouvez également configurer user.name et user.email pour ce projet:

git config user.name USERNAME
git config user.email USERNAME@example.com

Se mettre en forme

Pour gérer un dépôt git sous un compte github / bitbucket / quel que soit le compte, il vous suffit de générer une nouvelle clé SSH.

Mais avant de pouvoir commencer à pousser / tirer REPOS avec votre seconde identité, nous dois vous mettre en forme - Supposons que votre système est configuré avec un type id_rsaet une id_rsa.pubpaire de clés. En ce moment, votre tree ~/.sshapparence ressemble à ceci

$ tree ~/.ssh
/Users/you/.ssh
├── known_hosts
├── id_rsa
└── id_rsa.pub

Tout d'abord, nommez cette paire de clés - l'ajout d'un nom descriptif vous aidera à vous rappeler quelle clé est utilisée pour quel utilisateur / télécommande

# change to your ~/.ssh directory
$ cd ~/.ssh

# rename the private key
$ mv id_rsa github-mainuser

# rename the public key
$ mv id_rsa.pub github-mainuser.pub

Ensuite, générons une nouvelle paire de clés - ici, je vais nommer la nouvelle clégithub-otheruser

$ ssh-keygen -t rsa -b 4096 -f ~/.ssh/github-otheruser

Maintenant, quand on regarde tree ~/.sshon voit

$ tree ~/.ssh
/Users/you/.ssh
├── known_hosts
├── github-mainuser
├── github-mainuser.pub
├── github-otheruser
└── github-otheruser.pub

Ensuite, nous devons configurer un ~/.ssh/configfichier qui définira nos configurations clés. Nous allons le créer avec les autorisations appropriées en lecture / écriture uniquement du propriétaire

$ (umask 077; touch ~/.ssh/config)

Ouvrez-le avec votre éditeur préféré et ajoutez le contenu suivant

Host github.com
  User git
  IdentityFile ~/.ssh/github-mainuser

Host github.com-otheruser
  HostName github.com
  User git
  IdentityFile ~/.ssh/github-otheruser

Vraisemblablement, vous aurez des dépôts existants associés à votre identité github principale. Pour cette raison, github.com "par défaut" Hostest configuré pour utiliser votre mainuserclé. Si vous ne souhaitez pas privilégier un compte plutôt qu'un autre, je vais vous montrer comment mettre à jour les dépôts existants sur votre système pour utiliser une configuration ssh mise à jour.

Ajoutez votre nouvelle clé SSH à github

Rendez-vous sur github.com/settings/keys pour ajouter votre nouvelle clé publique

Vous pouvez obtenir le contenu de la clé publique en utilisant: copiez / collez-le dans github

$ cat ~/.ssh/github-otheruser.pub
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDBVvWNQ2nO5...

Maintenant, votre nouvelle identité d'utilisateur est entièrement configurée - ci-dessous, nous vous montrerons comment l'utiliser.

Faire avancer les choses: cloner un dépôt

Alors, comment cela fonctionne-t-il pour fonctionner avec git et github? Eh bien, parce que vous ne pouvez pas avoir un poulet sans et un œuf, nous examinerons le clonage d'un dépôt existant. Cette situation peut s'appliquer à vous si vous avez un nouveau compte Github pour votre lieu de travail et que vous avez été ajouté à un projet d'entreprise.

Disons github.com/someorg/somerepoqu'il existe déjà et que vous y avez été ajouté - le clonage est aussi simple que

$ git clone github.com-otheruser:someorg/somerepo.git

Cette partie en gras doit correspondre au Hostnom que nous avons configuré dans votre ~/.ssh/configfichier. Cela connecte correctement git au correspondant IdentityFileet vous authentifie correctement avec github

Faire avancer les choses: créer un nouveau référentiel

Eh bien, parce que vous ne pouvez pas avoir un poulet sans et un œuf, nous envisagerons de publier un nouveau dépôt sur votre compte secondaire. Cette situation s'applique aux utilisateurs qui créent un nouveau contenu à l'aide de leur compte github secondaire.

Supposons que vous ayez déjà fait un peu de travail localement et que vous êtes maintenant prêt à pousser vers github. Vous pouvez me suivre si vous le souhaitez

$ cd ~
$ mkdir somerepo
$ cd somerepo
$ git init

Maintenant, configurez ce dépôt pour utiliser votre identité

$ git config user.name "Mister Manager"
$ git config user.email "someuser@some.org"

Faites maintenant votre premier commit

$ echo "hello world" > readme
$ git add .
$ git commit -m "first commit"

Vérifiez le commit pour voir que votre nouvelle identité a été utilisée à l'aide de git log

$ git log --pretty="%H %an <%ae>"
f397a7cfbf55d44ffdf87aa24974f0a5001e1921 Mister Manager <someuser@some.org>

D'accord, il est temps de pousser vers github! Puisque github ne connaît pas encore notre nouveau repo, allez d'abord sur github.com/new et créez votre nouveau repo - nommez-le somerepo

Maintenant, pour configurer votre référentiel pour "parler" à github en utilisant la bonne identité / informations d'identification, nous avons ajouté une télécommande. En supposant que votre nom d'utilisateur github pour votre nouveau compte est someuser...

$ git remote add origin github.com-otheruser:someuser/somerepo.git

Cette partie en gras est absolument critique et doit correspondre à celle Hostque nous avons définie dans votre ~/.ssh/configfichier

Enfin, poussez le repo

$ git push origin master

Mettre à jour un référentiel existant pour utiliser une nouvelle configuration SSH

Supposons que vous ayez déjà un référentiel cloné, mais que vous souhaitez maintenant utiliser une nouvelle configuration SSH. Dans l'exemple ci-dessus, nous avons conservé votre repos existant en affectant votre paire précédente id_rsa/ id_rsa.pubclé à Host github.comdans votre fichier de configuration SSH. Il n'y a rien de mal à cela, mais j'ai maintenant au moins 5 configurations github et je n'aime pas penser à l'une d'entre elles comme la configuration "par défaut" - je préfère être explicite à propos de chacune.

Avant d'avoir ça

Host github.com
  User git
  IdentityFile ~/.ssh/github-mainuser

Host github.com-otheruser
  HostName github.com
  User git
  IdentityFile ~/.ssh/github-otheruser

Nous allons donc maintenant mettre cela à jour (changements en gras )

Host github.com-mainuser
  HostName github.com
  User git
  IdentityFile ~/.ssh/github-mainuser

Host github.com-otheruser
  HostName github.com
  User git
  IdentityFile ~/.ssh/github-otheruser

Mais cela signifie que désormais tout dépôt existant avec une github.comtélécommande ne fonctionnera plus avec ce fichier d'identité. Mais ne vous inquiétez pas, c'est une solution simple.

Pour mettre à jour un référentiel existant pour utiliser votre nouvelle configuration SSH, ouvrez simplement le fichier de configuration git du référentiel et mettez à jour l'URL!

$ cd existingrepo
$ nano .git/config

Mettre à jour le champ d'origine à distance (modifications en gras )

[remote "origin"]
        url = github.com-mainuser:someuser/existingrepo.git
        fetch = +refs/heads/*:refs/remotes/origin/*

C'est ça. Maintenant, vous pouvez push/ pullau contenu de votre cœur

Autorisations du fichier de clé SSH

Si vous rencontrez des problèmes avec vos clés publiques qui ne fonctionnent pas correctement, SSH est assez strict sur les autorisations de fichiers autorisées sur votre ~/.sshrépertoire et les fichiers de clés correspondants

En règle générale, tous les répertoires doivent l'être 700et tous les fichiers doivent l'être 600- cela signifie qu'ils sont en lecture / écriture uniquement par le propriétaire - aucun autre groupe / utilisateur ne peut les lire / écrire

$ chmod 700 ~/.ssh
$ chmod 600 ~/.ssh/config
$ chmod 600 ~/.ssh/github-mainuser
$ chmod 600 ~/.ssh/github-mainuser.pub
$ chmod 600 ~/.ssh/github-otheruser
$ chmod 600 ~/.ssh/github-otheruser.pub

Comment je gère mes clés SSH

Je gère des clés SSH distinctes pour chaque hôte auquel je me connecte, de sorte que si une clé est compromise, je n'ai pas à mettre à jour les clés à tous les autres endroits où j'ai utilisé cette clé. C'est comme lorsque vous recevez la notification d'Adobe que 150 millions des informations de leurs utilisateurs ont été volées - vous devez maintenant annuler cette carte de crédit et mettre à jour tous les services qui en dépendent - quelle nuisance.

Voici à quoi ~/.sshressemble mon annuaire: J'ai une .pemclé pour chaque utilisateur, dans un dossier pour chaque domaine auquel je me connecte. J'utilise des .pemclés pour que je n'aie besoin que d' un fichier par clé.

$ tree ~/.ssh
/Users/naomik/.ssh
├── config
├── github.com
│   ├── naomik.pem
│   ├── someusername.pem
├── known_hosts
├── naomi.makes.software
│   ├── naomi.pem
├── somedomain.com
│   ├── someuser.pem
└── someotherdomain.org
    └── someuser.pem

Et voici mon /.ssh/configfichier correspondant - évidemment, le truc github est pertinent pour répondre à cette question sur github, mais cette réponse vise à vous donner les connaissances nécessaires pour gérer vos identités ssh sur n'importe quel nombre de services / machines.

Host github.com-naomik
  HostName github.com
  User git
  IdentityFile ~/.ssh/github.com/naomik.pem

Host github.com-someuser
  HostName github.com
  User git
  IdentityFile ~/.ssh/github.com/someusername.pem

Host naomi.makes.software
  User naomi
  IdentityFile ~/.ssh/naomi.makes.software/naomi.pem

Host somedomain.com
  HostName 162.10.20.30
  User someuser
  IdentityFile ~/.ssh/somedomain.com/someuser.pem

Host someotherdomain.org
  User someuser
  IdentityFile ~/.ssh/someotherdomain.org/someuser.pem

Obtenir votre clé publique SSH à partir d'une clé PEM

Ci-dessus, vous avez remarqué que je n'ai qu'un seul fichier pour chaque clé. Lorsque je dois fournir une clé publique, je la génère simplement au besoin.

Donc, quand github demande votre clé publique ssh, exécutez cette commande pour sortir la clé publique sur stdout - copiez / collez là où vous en avez besoin

$ ssh-keygen -y -f someuser.pem
ssh-rsa AAAAB3NzaC1yc2EAAAA...

Remarque, c'est également le même processus que j'utilise pour ajouter ma clé à n'importe quelle machine distante. La ssh-rsa AAAA...valeur est copiée dans le ~/.ssh/authorized_keysfichier de la télécommande

Conversion de vos paires id_rsa/ id_rsa.pubclés au format PEM

Donc, vous voulez apprivoiser vos fichiers clés et réduire la corruption de votre système de fichiers? Convertir votre paire de clés en un seul PEM est facile

$ cd ~/.ssh
$ openssl rsa -in id_rsa -outform pem > id_rsa.pem

Ou, en suivant nos exemples ci-dessus, nous avons renommé id_rsa -> github-mainuseret id_rsa.pub -> github-mainuser.pub- donc

$ cd ~/.ssh
$ openssl rsa -in github-mainuser -outform pem > github-mainuser.pem

Maintenant, juste pour vous assurer que nous avons converti cela correctement, vous voudrez vérifier que la clé publique générée correspond à votre ancienne clé publique

# display the public key
$ cat github-mainuser.pub
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAA ... R++Nu+wDj7tCQ==

# generate public key from your new PEM
$ ssh-keygen -y -f someuser.pem
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAA ... R++Nu+wDj7tCQ==

Maintenant que vous avez votre github-mainuser.pemfichier, vous pouvez supprimer en toute sécurité vos anciens fichiers github-mainuseret github-mainuser.pub- seul le fichier PEM est nécessaire; il suffit de générer la clé publique chaque fois que vous en avez besoin ^ _ ^

Création de clés PEM à partir de zéro

Vous n'avez pas besoin de créer la paire de clés privée / publique, puis de la convertir en une seule clé PEM. Vous pouvez créer directement la clé PEM.

Créons un newuser.pem

$ openssl genrsa -out ~/.ssh/newuser.pem 4096

Obtenir la clé publique SSH est la même

$ ssh-keygen -y -f ~/.ssh/newuser.pem
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACA ... FUNZvoKPRQ==

En créant différents alias d'hôte pour github.com dans votre ~ / .ssh / config, et en donnant à chaque alias d'hôte sa propre clé ssh, vous pouvez facilement utiliser plusieurs comptes github sans confusion. C'est parce que github.com ne distingue pas par utilisateur, ce qui est toujours juste git, mais par la clé ssh que vous avez utilisée pour vous connecter. Configurez simplement vos origines distantes à l'aide de vos propres alias d'hôte. »

Le résumé ci-dessus est une gracieuseté des commentaires sur le blog ci-dessous.

J'ai trouvé cette explication la plus claire. Et cela fonctionne pour moi, au moins depuis avril 2012.

http://net.tutsplus.com/tutorials/tools-and-tips/how-to-work-with-github-and-multiple-accounts/

Les détails sur http://net.tutsplus.com/tutorials/tools-and-tips/how-to-work-with-github-and-multiple-accounts/ liés à par mishaba fonctionnent très bien pour moi.

Depuis cette page:

$ touch ~/.ssh/config

Modifiez ensuite ce fichier pour qu'il ressemble à ceci (une entrée par compte):

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

Host github-COMPANY
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_rsa_COMPANY

• Allez dans ~ / .ssh
• Créez un fichier nommé config (sans extension)

• Ouvrez le fichier de configuration et ajoutez les codes ci-dessous. (changez selon votre compte)

  1. Compte 1

     # account_1
     Host gitlab.com-account_1
     HostName gitlab.com
     User git
     PreferredAuthentications publickey
     IdentityFile ~/.ssh/id_rsa_account_1
     

  2. Compte 2

     # Account2
     Host gitlab.com-Account2
     HostName gitlab.com
     User git
     PreferredAuthentications publickey
     IdentityFile ~/.ssh/id_rsa_Account2
     

  3. Compte 3

     # Account_3
     Host github.com-Account3
     HostName github.com
     User git
     PreferredAuthentications publickey
     IdentityFile ~/.ssh/id_rsa_Account_3
     

• Ajouter une URL distante comme suit

  1. Compte 1

     git remote add origin git@gitlab.com-account_1:group_name/repo_name.git
     

  2. Compte 2

     git remote add origin git@gitlab.com-Account2:group_name/repo_name.git
     

  3. Compte 3

     git remote add origin github.com-Account3:github_username/repo_name.git
     

Assurez-vous que les noms IdentityFile sont identiques à ceux que vous avez créés lors de la génération de clé ssh.

J'utilise des scripts shell pour me basculer sur le compte que je veux être "actif". Essentiellement, vous partez d'un nouveau départ, obtenez un compte correctement configuré et fonctionnel, puis déplacez ces fichiers vers un nom avec le préfixe approprié. A partir de là, vous pouvez utiliser la commande "github" ou "gitxyz" pour basculer:

# my github script
cd ~/.ssh

if [ -f git_dhoerl -a -f git_dhoerl.pub -a -f config_dhoerl ]
then
    ; 
else 
    echo "Error: missing new files"
    exit 1
fi 

# Save a copy in /tmp, just in case
cp id_rsa /tmp
cp id_rsa.pub /tmp
cp config /tmp
echo "Saved old files in /tmp, just in case"

rm id_rsa
rm id_rsa.pub
rm config
echo "Removed current links/files"

ln git_dhoerl id_rsa
ln git_dhoerl.pub id_rsa.pub
ln config_dhoerl config

git config --global user.email "dhoerl@<company>.com"
git config --global github.user "dhoerl"        
git config --global github.token "whatever_it_is"

ssh-add -D

J'ai eu beaucoup de chance avec ça. J'ai également créé un script d'exécution dans Xcode (pour vous les utilisateurs Mac) afin qu'il ne construise pas mon projet à moins d'avoir le bon paramètre (car il utilise git):

Exécutez le script placé après les dépendances (en utilisant / bin / ksh comme shell):

if [ "$(git config --global --get user.email)" != "dhoerl@<company>.com" ]
then
    exit 1
fi

EDIT: ajout de tests pour l'existence de nouveaux fichiers et copie d'anciens fichiers dans / tmp pour répondre au commentaire de @naomik ci-dessous.

Cette réponse est pour les débutants (gourous non-git) . J'ai récemment eu ce problème et c'est peut-être juste moi, mais la plupart des réponses semblaient nécessiter une compréhension plutôt avancée de git. Après avoir lu plusieurs réponses de débordement de pile, y compris ce fil, voici les étapes à suivre pour basculer facilement entre les comptes GitHub (par exemple, supposez deux comptes GitHub, github.com/personal et gitHub.com/work ):

1. Vérifiez les clés ssh existantes: ouvrez Terminal et exécutez cette commande pour voir / répertorier lesls -al ~/.ssh
   fichiers declés ssh existantsavec l'extension.pubsont vos clés ssh, vous devez donc en avoir deux pour lescomptespersonaletwork. S'il n'y en a qu'un ou aucun, il est temps de générer un autre sage.
   
   - Génération de la clé ssh : connectez-vous à github (soit le compte personnel ou professionnel), accédez aux paramètres et copiez l'e-mail associé.
   maintenant, revenez à Terminal et exécutezssh-keygen -t rsa -C "the copied email", vous verrez:
   
   Génération d'une paire de clés publique / privée rsa.
   Entrez le fichier dans lequel enregistrer la clé (/.../.ssh/id_rsa):
   
   id_rsa est le nom par défaut de la clé ssh qui sera bientôt générée, alors copiez le chemin et renommez la valeur par défaut, par exemple /.../.ssh/id_rsa_worksi vous générez pour le compte professionnel. fournissez un mot de passe ou entrez simplement pour ignorer et, vous lirez quelque chose comme l'image randomart de la clé est: et l'image. terminé.
   Répétez cette étape une fois de plus pour votre deuxième compte github. Assurez-vous d'utiliser la bonne adresse e-mail et un nom de clé ssh différent (par exemple id_rsa_personal) pour éviter l'écrasement.
   À ce stade, vous devriez voir deux clés ssh lors de la ls -al ~/.sshnouvelle exécution .
2. Associer la clé ssh au compte gitHub: L'étape suivante consiste à copier l'une des clés ssh, exécutez-la en remplaçant votre propre nom de clé ssh:, pbcopy < ~/.ssh/id_rsa_work.pubremplacez id_rsa_work.pubpar ce que vous avez appelé le vôtre.
   Maintenant que notre clé ssh est copié dans le presse - papiers, retournez au compte github [Assurez- vous que vous êtes connecté au compte de travail si la clé ssh vous avez copié est id_rsa_work] et naviguer à
   Paramètres - SSH et clés GPG et cliquez sur Nouvelle clé SSH bouton (pas Nouvelle clé GPG btw: D)
   donnez un titre à cette clé, collez-la et cliquez sur Ajouter une clé SSH. Vous avez maintenant soit ajouté la clé ssh avec succès, soit remarqué qu'elle a toujours été là, ce qui est correct (ou vous avez une erreur car vous avez sélectionné Nouvelle clé GPG au lieu deNouvelle clé SSH : D).
3. Associer la clé ssh au compte gitHub : répétez l'étape ci-dessus pour votre deuxième compte.

4. Modifier la configuration globale de git: La dernière étape consiste à s'assurer que le fichier de configuration globale est au courant de tous les comptes github (pour ainsi dire).
   Exécutez git config --global --editpour modifier ce fichier global, si cela ouvre vim et que vous ne savez pas comment l'utiliser, appuyez sur ipour passer en mode Insertion, modifiez le fichier comme ci-dessous et appuyez sur esc puis :wqpour quitter le mode insertion:

   [inside this square brackets give a name to the followed acc.] name = github_username email = github_emailaddress [any other name] name = github_username email = github_email [credential] helper = osxkeychain useHttpPath = true

Terminé! Maintenant, lorsque vous essayez de pousser ou de retirer d'un référentiel, il vous sera demandé quel compte GitHub doit être lié à ce référentiel et sa seule demande, la configuration locale se souviendra de ce lien et non de la configuration globale afin que vous puissiez travailler sur différents dépôts liés à différents comptes sans avoir à modifier la configuration globale à chaque fois.

Solution plus simple et facile pour éviter les confusions ..

Pour les utilisateurs de Windows, utiliser plusieurs ou différents comptes git pour différents projets.

Étapes suivantes: Accédez au Panneau de configuration et recherchez Credential Manager. Ensuite, allez dans Credential Manager -> Windows Credentials

Maintenant, supprimez le nœud git: https // github.com sous l'en-tête Generic Credentials

Cela supprimera les informations d'identification actuelles. Vous pouvez maintenant ajouter n'importe quel projet via git pull, il vous demandera un nom d'utilisateur et un mot de passe.

Lorsque vous rencontrez un problème avec un autre compte, suivez le même processus.

Merci

se référer à l'image

vient de comprendre cela pour Windows, en utilisant les informations d'identification pour chaque dépôt:

cd c:\User1\SomeRepo
git config --local credential.https://github.com.user1 user1
git config --local credential.useHttpPath true
git config --local credential.helper manager
git remote set-url origin https://USERNAME@github.com/USERNAME/PROJECTNAME.git

Le format des informations d'identification. https://github.com . indique à l'assistant d'informations d'identification l'URL des informations d'identification. 'UseHttpPath' indique au gestionnaire d'informations d'identification d'utiliser le chemin d'accès pour les informations d'identification. Si useHttpPath est omis, le gestionnaire d'informations d'identification stockera une information d'identification pour https://github.com . S'il est inclus, le gestionnaire d'informations d'identification stockera plusieurs informations d'identification, ce que je voulais vraiment.

J'ai trouvé ce bijou très utile: sshwitch

https://github.com/agush22/sshwitch
http://rubygems.org/gems/sshwitch

Cela aide à désactiver les clés ssh. N'oubliez pas de tout sauvegarder en premier!

De plus, pour m'assurer que les validations sont associées à la bonne adresse e-mail, j'ai vérifié que le fichier ~ / .gitconfig avait la bonne adresse e-mail.

En plus de créer plusieurs clés SSH pour plusieurs comptes, vous pouvez également envisager d'ajouter des collaborateurs sur chaque projet en utilisant les mêmes e-mails de compte et de stocker le mot de passe de manière permanente.

#this store the password permanently
$ git config --global credential.helper wincred

J'ai configuré plusieurs comptes avec différents e-mails, puis j'ai mis le même utilisateur et le même e-mail sur chaque compte que l'un des collaborateurs. De cette façon, je peux accéder à tous les comptes sans ajouter de clé SSH ou passer à un autre nom d'utilisateur et envoyer un e-mail pour l'authentification.

L'approche la plus simple et la plus simple (à mon humble avis) - pas de fichiers de configuration pas trop de tracas

Créez simplement une autre clé ssh.

Disons que vous avez un nouveau compte GitHub de travail, créez simplement une nouvelle clé pour cela:

sh-keygen -t rsa -C "email@work_mail.com" -f "id_rsa_work_user1"`

Maintenant, vous devriez avoir l'ancien et le nouveau, pour les voir, exécutez:

ls -al ~/.ssh

Vous devez exécuter ce qui précède une seule fois.

À partir de maintenant, chaque fois que vous souhaitez basculer entre les deux, lancez simplement:

ssh-add -D
ssh-add ~/.ssh/id_rsa_work_user1 #make to use this without the suffix .pub

Pour passer à l'ancien, exécutez à nouveau:

 ssh-add -D
 ssh-add ~/.ssh/<previous id_rsa>

une autre façon plus simple consiste à utiliser plusieurs applications de bureau, comme ce que je fais, en utilisant le compte A sur le bureau Github, tout en utilisant le compte B sur Github Kraken

IntelliJ Idea a une prise en charge intégrée de cette https://www.jetbrains.com/help/idea/github.html#da8d32ae

Dans le cas où vous ne voulez pas jouer avec le ~/.ssh/configfichier mentionné ici, vous pouvez plutôt exécuter git config core.sshCommand "ssh -i ~/.ssh/custom_id_rsa"dans le référentiel où vous souhaitez valider à partir d'un autre compte.

Le reste de la configuration est le même:

1. Créez une nouvelle clé SSH pour le deuxième compte avec ssh-keygen -t rsa -f ~/.ssh -f ~/.ssh/custom_id_rsa

2. Connectez-vous à github avec votre autre compte, accédez à https://github.com/settings/keys et collez le contenu de~/.ssh/custom_id_rsa.pub

3. Assurez-vous que vous utilisez SSH au lieu de HTTPS comme URL distante: git remote set-url origin git@github.com:upstream_project_teamname/upstream_project.git

Vous n'êtes pas obligé de gérer deux comptes différents pour le personnel et le travail. En fait, Github vous recommande de conserver un seul compte et vous aide à fusionner les deux.

Suivez le lien ci-dessous pour fusionner si vous décidez qu'il n'est pas nécessaire de gérer plusieurs comptes.

https://help.github.com/articles/merging-multiple-user-accounts/

Contrairement à d'autres réponses, où vous devez suivre quelques étapes pour utiliser deux comptes Github différents de la même machine, pour moi, cela a fonctionné en deux étapes .

Il vous suffit de:

1) Générez une paire de clés SSH publique et privée pour chacun de vos comptes sous un ~/.sshemplacement avec des noms différents et

2) ajoutez les clés publiques générées au compte respectif sous Settings>> SSH and GPG keys>>New SSH Key .

Pour générer les paires de clés publiques et privées SSH, utilisez la commande suivante:

cd ~/.ssh
ssh-keygen -t rsa -C "email@work.com" -f "id_rsa_WORK"
ssh-keygen -t rsa -C "email@gmail.com" -f "id_rsa_PERSONAL"

En conséquence des commandes ci - dessus, id_rsa_WORKet les id_rsa_WORK.pubfichiers seront créés pour votre travail compte (ex - git.work.com) et id_rsa_PERSONALet id_rsa_PERSONAL.pubsera créé pour votre personnel compte (ex - github.com).

Une fois créé, copiez le contenu de chaque *.pubfichier public ( ) et effectuez l'étape 2 pour chaque compte.

PS : Il n'est pas nécessaire de faire une entrée d'hôte pour chaque compte git sous ~/.ssh/configfichier comme mentionné dans les autres réponses, si le nom d'hôte de vos deux comptes est différent.

S'il vous arrive d'avoir WSL installé vous pouvez avoir deux comptes git séparés - un sur WSL et un dans Windows.

Vous devez et ne devez pas pousser vers le projet avec des informations d'identification communes. Une fois que vous démarrez sur une nouvelle machine, utilisez les étapes suivantes pour configurer et utiliser correctement vos informations d'identification gitlab:

• créer les clés ssh pubiennes / privées sur la machine
• copiez collez la clé publique sur l'interface utilisateur de gitlab / github (toute personne suggérant comment faire via la ligne cmd obtient une bière gratuite ...)
• assurez-vous de cloner le dépôt via le git et non l'URL http
• définissez l'alias git pour éviter de taper constamment le même préfixe à la commande git
• pendant git commit TOUJOURS utiliser les drapeaux auteur et e-mail
• utilisez git comme d'habitude vous le feriez

Tout cela comme suit:

 # create the public / private key credentials on that specific machine
 ssh-keygen -t rsa -b 4096 -C "<<you>>@org.net" -f ~/.ssh/id_rsa.<<you>>.`hostname -s`

 # setup your public key in the gitlab ui 
 cat ~/.ssh/id_rsa.<<you>>.`hostname -s`

 # make sure you clone the repo via the git and not http url
 git clone git@git.in.org.net:org/some-repo.git

 # set the git alias to avoid constant typing of the repeating prefix to the git cmd
 alias git='GIT_SSH_COMMAND="ssh -i ~/.ssh/id_rsa.<<you>>.`hostname -s`" git'

 # during git commit ALWAYS use the author and e-mail flags
 git add --all ; git commit -nm "$git_msg" --author "YourFirstName YourLastName <you@phz.fi>"

 # use git as normal
 git fetch --all; git pull --all 

1. Accédez au répertoire dans lequel vous souhaitez transférer vos modifications vers un autre compte GitHub.

2. Créez une nouvelle clé SSH dans votre terminal / ligne de commande.

   ssh-keygen -t rsa -C "votre-adresse-e-mail"

3. Ce qui suit montrera alors:

   Génération d'une paire de clés rsa publique / privée. Entrez le fichier dans lequel enregistrer la clé (/home/your_username/.ssh/id_rsa):

Copiez et collez le chemin suivi d'un nom identifiable pour le fichier:

/home/your_username/.ssh/id_rsa_personal

4) Il vous demandera alors les informations suivantes:

Enter passphrase (empty for no passphrase):
Enter same passphrase again:

5) Vous pouvez maintenant taper la commande suivante pour voir toutes les clés SSH que vous avez sur votre machine locale:

ls -al ~/.ssh

Vous devriez pouvoir voir votre nouveau fichier de clé SSH. Comme vous pouvez le voir dans mon article, j'ai à la fois id_rsa_test et id_rsa_personal.pub.

drwx------  2 gmadmin gmadmin 4096 Nov 16 22:20 .
drwxr-xr-x 42 gmadmin gmadmin 4096 Nov 16 21:03 ..
-rw-------  1 gmadmin gmadmin 1766 Nov 16 22:20 id_rsa_personal
-rw-r--r--  1 gmadmin gmadmin  414 Nov 16 22:20 id_rsa_personal.pub
-rw-r--r--  1 gmadmin gmadmin  444 Nov  6 11:32 known_hosts

6) Ensuite, vous devez copier la clé SSH qui est stockée dans le fichier id_rsa_personal.pub. Vous pouvez l'ouvrir dans l'éditeur de texte de votre choix. J'utilise actuellement atom alors j'ai ouvert le fichier en utilisant la commande suivante:

atom ~/.ssh/id_rsa_personal.pub

Vous obtiendrez alors quelque chose de similaire à ceci:

ssh-rsa AAB3HKJLKC1yc2EAAAADAQABAAABAQCgU5 + ELtwsKkmcoeF3hNd7d6CjW + dWut83R / Dc01E / YzLc5ZFri18doOwuQoeTPpmIRVDGuQQsZshjDrKWHKWHKWW

7) Copiez ceci et accédez à votre compte GitHub → Paramètres → Clés SSH et GPG 8) Cliquez sur Nouvelle clé SSH. Copiez la clé, donnez-lui un titre et ajoutez-la. 9) Ajouter une clé du terminal

ssh-add ~/.ssh/id_rsa_personal
Enter passphrase for /home/your_username/.ssh/id_rsa_personal: 

10) Configurez l'utilisateur et le mot de passe.

git config --global user.name "gitusername"
git config --global user.email "gitemail"

11) Nous sommes prêts à nous engager et à pousser maintenant.

git init
git add .
git commit 
git push

Si vous avez créé ou cloné un autre référentiel et que vous n'avez pas pu extraire originouupstream ajouter la clé ssh dans ce répertoire à l'aide de la commande suivante, travaillé.

Voici l'erreur que j'obtenais ici:

Warning: Permanently added the RSA host key for IP address '61:fd9b::8c52:7203' to the list of known hosts.
Permission denied (publickey).
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.

J'ai utilisé la commande suivante, cela fonctionne:

ssh-add ~/.ssh/id_rsa_YOUR_COMPANY_NAME