Várias contas do github no mesmo computador?

Tentando trabalhar nos meus repositórios reais de "trabalho" e nos repositórios pessoais no hub git, no meu computador.

A conta de trabalho foi configurada primeiro e tudo funciona na perfeição.

Minha conta pessoal, no entanto, não parece levar ao meu repo pessoal, que é configurado em uma conta / e-mail diferente.

Tentei copiar minha chave de trabalho para minha conta pessoal, mas isso gera um erro, porque é claro que uma chave pode ser anexada apenas a uma conta.

Como posso enviar / extrair para e de ambas as contas, de suas respectivas credenciais do github?

Tudo que você precisa fazer é definir sua configuração do SSH com vários pares de chaves SSH.

• É fácil seguir este link (Obrigado Eric): http://code.tutsplus.com/tutorials/quick-tip-how-to-work-with-github-and-multiple-accounts--net-22574

• Gerando chaves SSH (Win / msysgit) https://help.github.com/articles/generating-an-ssh-key/

Além disso, se você estiver trabalhando com vários repositórios usando diferentes personas, precisará garantir que seus repositórios individuais tenham as configurações do usuário substituídas de acordo:

Definindo nome de usuário, email e token do GitHub - Substituindo configurações de repositórios individuais https://help.github.com/articles/setting-your-commit-email-address-in-git/

Espero que isto ajude.

Nota: Alguns de vocês podem exigir que emails diferentes sejam usados ​​para repositórios diferentes. No git 2.13, você pode definir o email em um diretório editando o arquivo de configuração global encontrado em: ~/.gitconfigusando condicionais da seguinte forma:

[user]
    name = Pavan Kataria
    email = [email protected]

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

E então seu trabalho específico config ~ / work / .gitconfig ficaria assim:

[user]
    email = [email protected]

Obrigado @alexg por me informar disso nos comentários.

Use HTTPS:

altere o URL remoto para https:

git remote set-url origin https://[email protected]/USERNAME/PROJECTNAME.git

e você está pronto para ir:

git push

Para garantir que as confirmações apareçam como executadas por USERNAME, também é possível configurar o user.name e o user.email para este projeto:

git config user.name USERNAME
git config user.email [email protected]

Entrando em forma

Para gerenciar um repositório git em uma conta github / bitbucket / qualquer outra conta separada, basta gerar uma nova chave SSH.

Porém, antes que possamos começar a enviar / reposicionar repos com sua segunda identidade, precisamos colocar você em forma - vamos assumir que seu sistema está configurado com um par típico id_rsae de id_rsa.pubchaves. Agora, sua tree ~/.sshaparência se parece com isso

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

Primeiro, nomeie esse par de chaves - adicionar um nome descritivo ajudará a lembrar qual chave é usada para qual usuário / usuário remoto

# 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

Em seguida, vamos gerar um novo par de chaves - aqui vou nomear a nova chavegithub-otheruser

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

Agora, quando olhamos tree ~/.ssh, vemos

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

Em seguida, precisamos definir um ~/.ssh/configarquivo que definirá nossas configurações principais. Vamos criá-lo com as permissões apropriadas de leitura / gravação do proprietário

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

Abra isso com seu editor favorito e adicione o seguinte conteúdo

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

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

Presumivelmente, você terá alguns repositórios existentes associados à sua identidade principal do github. Por esse motivo, o github.com "padrão" Hostestá configurado para usar sua mainuserchave. Se você não deseja favorecer uma conta em detrimento de outra, mostrarei como atualizar os repositórios existentes no seu sistema para usar uma configuração ssh atualizada.

Adicione sua nova chave SSH ao github

Cabeça sobre a github.com/settings/keys para adicionar o seu novo público -chave

Você pode obter o conteúdo da chave pública usando: copie / cole no github

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

Agora sua nova identidade de usuário está configurada. Abaixo, mostraremos como usá-la.

Como fazer coisas: clonar um repositório

Então, como isso se junta para trabalhar com o git e o github? Bem, como você não pode ter uma galinha sem ovo, veremos a clonagem de um repositório existente. Essa situação pode se aplicar a você se você tiver uma nova conta do github para o seu local de trabalho e tiver sido adicionado a um projeto da empresa.

Digamos que github.com/someorg/somerepojá exista e você foi adicionado a ela - a clonagem é tão fácil quanto

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

Essa parte em negrito deve corresponder ao Hostnome que configuramos no seu ~/.ssh/configarquivo. Que conecta corretamente o git ao correspondente IdentityFilee o autentica corretamente com o github

Como fazer: criando um novo repositório

Bem, como você não pode ter uma galinha sem ovo, analisaremos a publicação de um novo repositório em sua conta secundária. Essa situação se aplica aos usuários que criam novo conteúdo usando sua conta secundária do github.

Vamos supor que você já tenha trabalhado um pouco localmente e agora esteja pronto para ir ao github. Você pode acompanhar-me se quiser

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

Agora configure este repositório para usar sua identidade

$ git config user.name "Mister Manager"
$ git config user.email "[email protected]"

Agora faça seu primeiro commit

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

Verifique o commit para ver se sua nova identidade foi usada usando o git log

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

Tudo bem, hora de empurrar para o github! Como o github ainda não conhece nosso novo repositório , primeiro vá para github.com/new e crie seu novo repositório - nomeie-o somerepo

Agora, para configurar seu repositório para "conversar" com o github usando a identidade / credenciais corretas, adicionamos um controle remoto. Supondo que seu nome de usuário no github para sua nova conta seja someuser...

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

Essa parte em negrito é absolutamente crítica e deve corresponder à Hostque definimos em seu ~/.ssh/configarquivo

Por fim, empurre o repositório

$ git push origin master

Atualize um repositório existente para usar uma nova configuração SSH

Digamos que você já tenha alguns repositórios clonados, mas agora você deseja usar uma nova configuração SSH. No exemplo acima, mantivemos seus repositórios existentes intactos, atribuindo seu par anterior id_rsa/ id_rsa.pubchave ao Host github.comseu arquivo de configuração SSH. Não há nada de errado nisso, mas agora tenho pelo menos 5 configurações do github e não gosto de pensar em uma delas como a configuração "padrão" - prefiro ser explícito sobre cada uma.

Antes de termos isso

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

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

Então, agora vamos atualizar isso para isso (alterações em negrito )

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

Mas isso significa que agora qualquer repo existente com um github.comcontrole remoto não funcionará mais com esse arquivo de identidade. Mas não se preocupe, é uma solução simples.

Para atualizar qualquer repositório existente para usar sua nova configuração SSH, basta abrir o arquivo de configuração git do repositório e atualizar o URL!

$ cd existingrepo
$ nano .git/config

Atualize o campo de origem remota (alterações em negrito )

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

É isso aí. Agora você pode push/ pullpara o conteúdo do seu coração

Permissões de arquivo de chave SSH

Se você estiver tendo problemas com as chaves públicas que não estão funcionando corretamente, o SSH é bastante rigoroso nas permissões de arquivo permitidas no ~/.sshdiretório e nos arquivos de chave correspondentes

Como regra geral, qualquer diretório deve ser 700e qualquer arquivo deve 600- isso significa que eles são de leitura / gravação somente pelo proprietário - nenhum outro grupo / usuário pode lê-los / gravá-los

$ 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

Como gerencio minhas chaves SSH

Eu gerencio chaves SSH separadas para todos os hosts aos quais me conecto, para que, se alguma chave for comprometida, não seja necessário atualizá-las em todos os outros locais em que as usei. É como quando você recebe a notificação da Adobe de que 150 milhões das informações de seus usuários foram roubadas - agora é necessário cancelar o cartão de crédito e atualizar todos os serviços que dependem dele - que incômodo.

Aqui está a ~/.sshaparência do meu diretório: Eu tenho uma .pemchave para cada usuário, em uma pasta para cada domínio ao qual me conecto. Eu uso .pemchaves para que eu só precise de um arquivo por chave.

$ 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

E aqui está o meu /.ssh/configarquivo correspondente - obviamente o material do github é relevante para responder a essa pergunta sobre o github, mas essa resposta tem como objetivo fornecer a você o conhecimento necessário para gerenciar suas identidades ssh em qualquer número de serviços / máquinas.

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

Obtendo sua chave pública SSH de uma chave PEM

Acima, você notou que só tenho um arquivo para cada chave. Quando preciso fornecer uma chave pública, simplesmente a gero conforme necessário.

Portanto, quando o github solicitar sua chave pública ssh, execute este comando para gerar a chave pública para stdout - copie / cole onde necessário

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

Observe que este também é o mesmo processo usado para adicionar minha chave a qualquer máquina remota. O ssh-rsa AAAA...valor é copiado para o ~/.ssh/authorized_keysarquivo do controle remoto

Convertendo seus pares de chaves id_rsa/ id_rsa.pubno formato PEM

Então, você quer domar seus arquivos-chave e reduzir alguns problemas do sistema de arquivos? É fácil converter seu par de chaves em um único PEM

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

Ou, seguindo os exemplos acima, renomeamos id_rsa -> github-mainusere id_rsa.pub -> github-mainuser.pub- então

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

Agora, apenas para garantir que convertemos isso corretamente, verifique se a chave pública gerada corresponde à sua chave pública antiga

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

Agora que você possui o seu github-mainuser.pemarquivo, é possível excluir com segurança os arquivos github-mainusere os github-mainuser.pubarquivos antigos - apenas o arquivo PEM é necessário; basta gerar a chave pública sempre que precisar ^ _ ^

Criando chaves PEM do zero

Você não precisa criar o par de chaves públicas / privadas e depois converter em uma única chave PEM. Você pode criar a chave PEM diretamente.

Vamos criar um newuser.pem

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

Obter a chave pública SSH é o mesmo

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

Criando aliases de host diferentes para o github.com em seu ~ / .ssh / config e fornecendo a cada alias de host sua própria chave ssh, você pode facilmente usar várias contas do github sem confusão. Isso ocorre porque o github.com distingue não o usuário, que é sempre apenas o git, mas a tecla ssh que você usou para se conectar. Basta configurar suas origens remotas usando seus próprios aliases de host. ”

O resumo acima é cortesia dos comentários na postagem do blog abaixo.

Eu achei essa explicação a mais clara. E funciona para mim, pelo menos a partir de abril de 2012.

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

Os detalhes em http://net.tutsplus.com/tutorials/tools-and-tips/how-to-work-with-github-and-multiple-accounts/ vinculados por mishaba funcionam muito bem para mim.

A partir dessa página:

$ touch ~/.ssh/config

Em seguida, edite esse arquivo para algo assim (uma entrada por conta):

#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

• Vá para ~ / .ssh
• Crie um arquivo chamado config (não tem extensão)

• Abra o arquivo de configuração e adicione os códigos abaixo. (mude de acordo com sua conta)

  1. Conta 1

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

  2. Conta 2

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

  3. Conta 3

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

• Adicione um URL remoto da seguinte maneira

  1. Conta 1

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

  2. Conta 2

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

  3. Conta 3

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

Verifique se os nomes do IdentityFile são os mesmos que você criou durante a geração da chave ssh.

Eu uso scripts de shell para mudar para qualquer conta que eu queira estar "ativa". Basicamente, você começa de novo, obtém uma conta configurada corretamente e funciona e depois move esses arquivos para um nome com o prefixo apropriado. A partir de então, você pode usar o comando "github" ou "gitxyz" para alternar:

# 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

Eu tive muita sorte com isso. Também criei um script de execução no Xcode (para você, usuários de Mac), para que ele não construísse meu projeto, a menos que eu tivesse a configuração adequada (desde que esteja usando o git):

Execute o script colocado após as dependências (usando / bin / ksh como shell):

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

EDIT: adicionamos testes para a existência de novos arquivos e copiamos arquivos antigos para / tmp para endereçar o comentário de @naomik abaixo.

Esta resposta é para iniciantes (gurus sem git) . Recentemente, tive esse problema e talvez seja apenas eu, mas a maioria das respostas parecia exigir uma compreensão bastante avançada do git. Após ler várias respostas de estouro de pilha, incluindo este thread, eis as etapas que eu precisava seguir para alternar facilmente entre contas do GitHub (por exemplo, assuma duas contas do GitHub, github.com/personal e gitHub.com/work ):

1. Verifique as chaves ssh existentes: Abra o Terminal e execute este comando para ver / listar osls -al ~/.ssh
   arquivos dechaves ssh existentescom extensão.pube suas chaves ssh, portanto, você deve ter dois para ascontaspersonalework. Se houver apenas um ou nenhum, é hora de gerar outro modo inteligente, pule isso.
   
   - Gerando chave ssh : faça login no github (pessoal ou profissional), navegue até Configurações e copie o email associado.
   agora volte ao Terminal e executessh-keygen -t rsa -C "the copied email", você verá:
   
   Gerando par de chaves rsa pública / privada.
   Digite o arquivo no qual salvar a chave (/.../.ssh/id_rsa):
   
   id_rsa é o nome padrão da chave ssh a ser gerada em breve, portanto copie o caminho e renomeie o padrão, por exemplo /.../.ssh/id_rsa_workse estiver gerando para uma conta de trabalho. forneça uma senha ou apenas entre para ignorar e, você lerá algo como a imagem randomart da chave é: e a imagem. feito.
   Repita esta etapa mais uma vez para sua segunda conta do github. Certifique-se de usar o endereço de e-mail correto e um nome de chave ssh diferente (por exemplo, id_rsa_personal) para evitar a substituição.
   Nesse estágio, você verá duas teclas ssh ao executar ls -al ~/.sshnovamente.
2. Associar chave ssh à conta do gitHub: O próximo passo é copiar uma das chaves ssh, execute isso, mas substituindo seu próprio nome de chave ssh :,pbcopy < ~/.ssh/id_rsa_work.pub substitua id_rsa_work.pubpelo que você chamou de seu.
   Agora que a nossa chave ssh é copiado para área de transferência, voltar a conta github [Certifique-se de que você está logado na conta de trabalho, se a chave ssh você copiou é id_rsa_work] e navegue até
   Configurações - SSH e Chaves GPG e clique em chave New SSH botão (não Nova chave GPG entre: D)
   dê um título para essa chave, cole a chave e clique em Adicionar chave SSH. Agora você adicionou com sucesso a chave ssh ou notou que ela estava lá o tempo todo, o que é bom (ou você recebeu um erro porque selecionou Nova chave GPG em vez deNova chave SSH : D).
3. Associar chave ssh à conta do gitHub : Repita a etapa acima para sua segunda conta.

4. Edite a configuração global do git: A última etapa é garantir que o arquivo de configuração global esteja ciente de todas as contas do github (por assim dizer).
   Execute git config --global --editpara editar este arquivo global, se isso abrir o vim e você não souber como usá-lo, pressione ipara entrar no modo Inserir, edite o arquivo como abaixo e pressione esc seguido por :wqpara sair do modo de inserção:

   [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

Concluído !, agora, ao tentar empurrar ou extrair de um repositório, você será perguntado sobre qual conta do GitHub deve ser vinculada a esse repositório e será solicitada apenas uma vez. A configuração local lembrará esse link e não a configuração global para que você possa trabalhar. em repositórios diferentes vinculados a contas diferentes sem precisar editar a configuração global a cada vez.

Correção mais simples e fácil para evitar confusões.

Para usuários do Windows usarem várias ou diferentes contas git para diferentes projetos.

Etapas a seguir: Vá no Painel de controle e procure pelo Credential Manager. Em seguida, vá para Credential Manager -> Credenciais do Windows

Agora remova o nó git: https // github.com em Cabeçalho de credenciais genéricas

Isso removerá as credenciais atuais. Agora você pode adicionar qualquer projeto através do git pull, ele pedirá nome de usuário e senha.

Quando você enfrentar algum problema com outra conta, faça o mesmo processo.

obrigado

consulte a imagem

acabei de descobrir isso no Windows, usando credenciais para cada repositório:

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://[email protected]/USERNAME/PROJECTNAME.git

O formato da credencial. https://github.com . informa ao auxiliar de credencial o URL da credencial. O 'useHttpPath' informa ao gerenciador de credenciais para usar o caminho para a credencial. Se useHttpPath for omitido, o gerenciador de credenciais armazenará uma credencial para https://github.com . Se estiver incluído, o gerente de credenciais armazenará várias credenciais, o que eu realmente queria.

Achei esta gema muito útil: sshwitch

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

Ajuda a trocar as chaves ssh. Lembre-se de fazer backup de tudo primeiro!

Também para garantir que as confirmações tenham o endereço de email correto associado, verifiquei se o arquivo ~ / .gitconfig tinha o endereço de email correto.

Além de criar várias chaves SSH para várias contas, você também pode adicionar colaboradores em cada projeto usando os mesmos e-mails da conta e armazenar a senha permanentemente.

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

Configurei várias contas com emails diferentes e depois coloquei o mesmo usuário e email em cada conta como um dos colaboradores. Dessa maneira, eu posso acessar todas as contas sem adicionar a chave SSH ou alternar para outro nome de usuário e enviar e-mail para autenticação.

A abordagem mais fácil e direta (IMHO) - sem arquivos de configuração, sem muito trabalho

Basta criar outra chave ssh.

Digamos que você tenha uma nova conta de trabalho do GitHub, basta criar uma nova chave para ela:

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

Agora você deve ter o antigo e o novo, para vê-los, execute:

ls -al ~/.ssh

Você precisa executar o procedimento acima apenas uma vez.

A partir de agora, toda vez que você quiser alternar entre os dois, basta executar:

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

Para mudar para o antigo, execute novamente:

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

Outra maneira mais fácil é usar vários aplicativos de desktop, como o que estou fazendo, usar a conta A no desktop do Github, enquanto usar a conta B no Github Kraken

O IntelliJ Idea oferece suporte interno para https://www.jetbrains.com/help/idea/github.html#da8d32ae

Caso você não queira mexer no ~/.ssh/configarquivo mencionado aqui, execute git config core.sshCommand "ssh -i ~/.ssh/custom_id_rsa"o repositório em que deseja confirmar a partir de uma conta diferente.

O restante da instalação é o mesmo:

1. Crie uma nova chave SSH para a segunda conta com ssh-keygen -t rsa -f ~/.ssh -f ~/.ssh/custom_id_rsa

2. Faça login no github com sua outra conta, acesse https://github.com/settings/keys e cole o conteúdo de~/.ssh/custom_id_rsa.pub

3. Verifique se você está usando SSH em vez de HTTPS como URL remoto: git remote set-url origin [email protected]:upstream_project_teamname/upstream_project.git

Você não precisa manter duas contas diferentes para uso pessoal e profissional. De fato, o Github recomenda que você mantenha uma única conta e ajude a mesclar as duas.

Siga o link abaixo para mesclar se você decidir que não há necessidade de manter várias contas.

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

Diferente de outras respostas, onde você precisa seguir algumas etapas para usar duas contas diferentes do github da mesma máquina, para mim funcionou em duas etapas .

Você só precisa:

1) gere um par de chaves pública e privada SSH para cada uma de sua conta em ~/.sshlocal com nomes diferentes e

2) adicione as chaves públicas geradas à respectiva conta em Settings>> SSH and GPG keys>>New SSH Key .

Para gerar os pares de chaves pública e privada SSH, use o seguinte comando:

cd ~/.ssh
ssh-keygen -t rsa -C "[email protected]" -f "id_rsa_WORK"
ssh-keygen -t rsa -C "[email protected]" -f "id_rsa_PERSONAL"

Como resultado de comandos acima, id_rsa_WORKe id_rsa_WORK.pubarquivos serão criados para o seu trabalho conta (ex - git.work.com) e id_rsa_PERSONALe id_rsa_PERSONAL.pubserá criado para o seu pessoal conta (ex - github.com).

Depois de criado, copie o conteúdo de cada *.pubarquivo public ( ) e execute a Etapa 2 para cada conta.

PS : não é necessário fazer uma entrada de host para cada conta git ~/.ssh/configarquivada, como mencionado em outras respostas, se o nome do host de suas duas contas for diferente.

Se você tiver o WSL instalado, poderá ter duas contas git separadas - uma no WSL e outra no Windows.

Você deve e não deve enviar para o projeto com algumas credenciais comuns. Depois de iniciar uma nova máquina, siga as etapas abaixo para configurar e usar corretamente suas credenciais do gitlab:

• crie as chaves ssh públicas / privadas na máquina
• copie e cole a chave pública na interface da interface do usuário do gitlab / github (qualquer pessoa que esteja dando dicas sobre como fazer por meio da linha cmd recebe uma cerveja grátis ...)
• certifique-se de clonar o repositório através do git e não do URL http
• configure o alias do git para evitar a digitação constante do mesmo prefixo no comando git
• durante o git commit SEMPRE use os sinalizadores de autor e email
• use git normalmente, você faria isso

Tudo isso da seguinte maneira:

 # 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 [email protected]: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 <[email protected]>"

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

1. Navegue até o diretório em que deseja enviar as alterações para uma conta diferente do GitHub.

2. Crie uma nova chave SSH no seu terminal / linha de comando.

   ssh-keygen -t rsa -C "seu-endereço-de-email"

3. O seguinte será mostrado:

   Gerando par de chaves rsa público / privado. Digite o arquivo no qual salvar a chave (/home/your_username/.ssh/id_rsa):

Copie e cole o caminho seguido por um nome identificável para o arquivo:

/home/your_username/.ssh/id_rsa_personal

4) Em seguida, solicitará o seguinte:

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

5) Agora você pode digitar o seguinte comando para ver todas as chaves SSH que você possui na sua máquina local:

ls -al ~/.ssh

Você poderá ver seu novo arquivo de chave SSH. Como você pode ver no meu, eu tenho id_rsa_test e 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) Em seguida, você precisa copiar a chave SSH que está armazenada no arquivo id_rsa_personal.pub. Você pode abrir isso no editor de texto de sua escolha. Atualmente, estou usando o atom, então abri o arquivo usando o seguinte comando:

atom ~/.ssh/id_rsa_personal.pub

Você obterá algo semelhante a este:

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

7) Copie isso e navegue para sua conta do GitHub → Configurações → Chaves SSH e GPG 8) Clique na nova chave SSH. Copie a chave, dê um título e adicione-o. 9) Adicionar chave do terminal

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

10) Configure usuário e senha.

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

11) Estamos prontos para confirmar e avançar agora.

git init
git add .
git commit 
git push

Se você criou ou clonou outro repositório e não conseguiu extrair originouupstream adicionar a chave ssh nesse diretório usando o seguinte comando funcionou.

Este é o erro que eu estava recebendo aqui:

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.

Eu usei o seguinte comando, isso funciona:

ssh-add ~/.ssh/id_rsa_YOUR_COMPANY_NAME