Como evito a especificação do nome de usuário e senha a cada git push?

Eu git push meu trabalho para um repository Git remoto.

Cada push me solicitará a input de username e password . Eu gostaria de evitá-lo para cada empurrão, mas como configurar para evitá-lo?

1. Gerar uma chave SSH

Linux / Mac

Abra o terminal para criar chaves ssh:

 cd ~ #Your home directory ssh-keygen -t rsa #Press enter for all values 

Para Windows

(Só funciona se o programa de submissão é capaz de usar certificados / chaves ssh privadas e públicas)

  1. Use Putty Gen para gerar uma chave
  2. Exportar a chave como uma chave SSH aberta

Aqui está um passo a passo sobre putty gen para os passos acima

2. Associe a chave SSH ao repository remoto

Este passo varia, dependendo de como o seu controle remoto está configurado.

  • Se for um repository GitHub e você tiver privilégios administrativos, vá para configurações e clique em “adicionar chave SSH”. Copie o conteúdo do seu ~/.ssh/id_rsa.pub no campo rotulado ‘Key’.

  • Se o seu repository é administrado por outra pessoa, dê ao administrador seu id_rsa.pub .

  • Se o seu repository remoto é administrado pelo seu, você pode usar este comando por exemplo:

    scp ~/.ssh/id_rsa.pub YOUR_USER@YOUR_IP:~/.ssh/authorized_keys/id_rsa.pub

3. Defina o seu URL remoto para um formulário que suporta SSH 1

Se você tiver feito as etapas acima e ainda estiver recebendo o aviso de senha, verifique se o URL do repo está no formulário

 git+ssh://git@github.com/username/reponame.git 

ao contrário de

 https://github.com/username/reponame.git 

Para ver o seu repo URL, execute:

 git remote show origin 

Você pode alterar o URL com:

 git remote set-url origin git+ssh://git@github.com/username/reponame.git 

[1] Esta seção incorpora a resposta de Eric P

Permanentemente autenticando com repositorys Git,

Execute o seguinte comando para ativar o armazenamento em cache da credencial.

 $ git config credential.helper store $ git push https://github.com/repo.git Username for 'https://github.com':  Password for 'https://USERNAME@github.com':  

Use também deve especificar o armazenamento em cache expire ,

 git config --global credential.helper 'cache --timeout 7200' 

Depois de habilitar o cache de credenciais, ele será armazenado em cache por 7200 segundos (2 horas) .

Nota: Auxiliar de credencial que armazena a senha não criptografada no disco local.

Se você já tiver suas chaves SSH configuradas e ainda estiver recebendo a solicitação de senha, verifique se o URL do repo está no formulário

 git+ssh://git@github.com/username/reponame.git 

ao contrário de

 https://github.com/username/reponame.git 

Para ver o seu repo URL, execute:

 git remote show origin 

Você pode alterar o URL com git remote set-url forma:

 git remote set-url origin git+ssh://git@github.com/username/reponame.git 

Apenas use a opção --repo para o comando git push. Como isso:

 $ git push --repo https://name:password@bitbucket.org/name/repo.git 

Salvando Indefinidamente

Você pode usar o git-credential-store via

 git config credential.helper store 

que armazena sua senha não criptografada no sistema de arquivos :

O uso desse ajudante armazenará suas senhas não criptografadas no disco, protegidas apenas por permissions do sistema de arquivos. Se essa não for uma troca de segurança aceitável, tente git-credential-cache ou encontre um assistente que se integre ao armazenamento seguro fornecido pelo sistema operacional.

Com um tempo limite

Use o git-credential-cache que, por padrão, armazena a senha por 15 minutos.

 git config credential.helper cache 

para definir um tempo limite diferente, use --timeout (aqui 5 minutos)

 git config credential.helper 'cache --timeout=300' 

Salvando com Segurança Indefinidamente (OS X e Windows)

  • Se você estiver usando um Mac, o Git vem com um modo “osxkeychain” , que armazena em cache credenciais nas chaves seguras que estão anexadas à sua conta do sistema. Esse método armazena as credenciais no disco e elas nunca expiram, mas são criptografadas com o mesmo sistema que armazena certificados HTTPS e preenchimentos automáticos do Safari.
  • Se você estiver usando o Windows, poderá instalar um assistente chamado “Git Credential Manager para Windows”. Isso é semelhante ao auxiliar “osxkeychain” descrito acima, mas usa o Windows Credential Store para controlar informações confidenciais. Ele pode ser encontrado em https://github.com/Microsoft/Git-Credential-Manager-for-Windows . [enfatiza o meu]

Eu estava usando o link https ( https://github.com/org/repo.git ) em vez do link ssh;

 git@github.com:org/repo.git 

Mudar resolveu o problema para mim!

Conecte seu cliente git ao seu armazenamento de credenciais do sistema operacional. Por exemplo, no Windows, você vincula o auxiliar de credencial ao wincred:

 git config --global credential.helper wincred 

Existe uma maneira de pular a digitação de senha ao usar https: // no GitHub?

Eu usei a resposta que Pavel sugeriu e funcionou para mim. Minha diferença era fazer isso enquanto eu adicionava o controle remoto da seguinte forma: git remote add (alias) https://(name:password)@github.com/(the remote address).git

Minha solução no Windows:

  1. Clique com o botão direito do mouse no diretório para pressionar e selecionar “Git Bash Here”.
  2. ssh-keygen -t rsa (Pressione enter para todos os valores)
  3. Verifique o terminal para: Your public key has been saved in /c/Users//.ssh/id_rsa.pub
  4. Copie a chave pública do arquivo especificado.
  5. Vá para o seu perfil do GitHub => Configurações => Chaves SSH e GPG => Nova chave SSH => Cole sua chave SSH lá => Salvar

No sistema operacional Windows, use isso, isso funciona para mim:

 https://{Username}:{Password}@github.com/{Username}/{repo}.git 

por exemplo

 git clone https://{Username}:{Password}@github.com/{Username}/{repo}.git git pull https://{Username}:{Password}@github.com/{Username}/{repo}.git git remote add origin https://{Username}:{Password}@github.com/{Username}/{repo}.git git push origin master 

Só queria apontar algo sobre a solução que disse acima várias vezes:

 git config credential.helper store 

Você pode usar qualquer comando que exija uma senha depois disso. Você não precisa empurrar. (você também pode puxar por exemplo) Depois disso, você não precisará digitar seu nome de usuário / senha novamente.

Tudo isso ocorre porque o git não fornece uma opção nos comandos clone / pull / push / fetch para enviar as credenciais através de um pipe. Embora ele forneça credential.helper, ele é armazenado no sistema de arquivos ou cria um daemon, etc. Geralmente, as credenciais do GIT são de nível de sistema e os ônus para mantê-los seguros estão no aplicativo invocando os comandos git. Muito insegura de fato.

Aqui está o que eu tive que trabalhar por aí. 1. A versão do Git (git –version) deve ser maior ou igual a 1.8.3.

GIT CLONE

Para clonagem, use “git clone URL” depois de alterar o URL no formato, http: // {myuser} @ {my_repo_ip_address} / {myrepo_name.git} para http: // {myuser}: {mypwd} @ {my_repo_ip_address} /{myrepo_name.git}

Em seguida, limpe o repository da senha como na próxima seção.

PURGING

Agora, isso teria ido e

  1. escreveu a senha em git remote origin. Digite “git remote -v” para ver o dano. Corrija isso definindo a URL de origem remota sem senha. “git remote set_url origem http: // {myuser} @ {my_repo_ip_address} / {myrepo_name.git}”
  2. escrito a senha em .git / logs no repository. Substitua todas as instâncias de pwd usando um comando unix como find .git / logs -exec sed -i ‘s / {my_url_with_pwd} // g’ {} \; Aqui, {my_url_with_pwd} é o URL com senha. Como o URL tem barras, ele precisa ser escapado por duas barras invertidas. Por ex, para o URL http: // kris: passs123@192.168.0.1/proj.git- > http: \\ / \\ / kris: passs123@192.168.0.1 \\ / proj.git

Se seu aplicativo estiver usando Java para emitir esses comandos, use ProcessBuilder em vez de Runtime. Se você precisar usar o Runtime, use getRunTime () .execute o array String como argumentos com / bin / bash e -c como argumentos, em vez daquele que usa uma única String como argumento.

GIT FETCH / PULL / PUSH

  1. defina a senha no git remote url como: “git remote set_url origem http: // {myuser}: {mypwd} @ {my_repo_ip_address} / {myrepo_name.git}”
  2. Emita o comando git fetch / push / pull. Você não será solicitado a senha.
  3. Faça a limpeza como na seção anterior. Não perca.

Se o seu PC é seguro ou você não se importa com a segurança da senha, isso pode ser conseguido de maneira muito simples. Assumindo que o repository remoto está no GitHub e origin é o seu nome local para o repository remoto, use este comando

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

O sinalizador --push garante que isso altere a URL do repository apenas para o comando git push . (A pergunta feita no post original é apenas sobre git push comando git push . Requerer um nome de usuário + senha somente para operações push é a configuração normal para repositorys públicos no GitHub. Note que repositorys privados no GitHub também requerem um nome de usuário + senha para pull e buscar operações, portanto, para um repository privado, você não desejaria usar o --push flag …)

AVISO: Isso é inerentemente inseguro porque:

  1. seu ISP, ou qualquer pessoa que registre seus accesss à rede, pode ver facilmente a senha em texto simples no URL;

  2. Qualquer pessoa que tenha access ao seu PC pode ver sua senha usando git remote show origin .

É por isso que usar uma chave SSH é a resposta aceita.

Mesmo uma chave SSH não é totalmente segura . Qualquer pessoa que ganhe access ao seu PC ainda pode, por exemplo, fazer pushs que destruam seu repository ou – pior – enviar commits fazendo mudanças sutis em seu código. (Todos os commits com push são obviamente altamente visíveis no GitHub. Mas se alguém quiser alterar o seu código sub-repticiamente, eles podem – --amend um commit anterior sem alterar a mensagem de commit, e então forçar o push. Isso seria furtivo e bastante difícil de perceber na prática.)

Mas revelar sua senha é pior . Se um invasor obtiver conhecimento de seu nome de usuário + senha, ele poderá bloquear sua conta, excluir sua conta, excluir permanentemente o repository etc.


Alternativamente – para simplicidade e segurança – você pode fornecer apenas o seu nome de usuário no URL, para que você tenha que digitar sua senha toda vez que você git push mas você não terá que dar seu nome de usuário a cada vez. (Eu gosto dessa abordagem, ter que digitar a senha me dá uma pausa para pensar cada vez que eu git push , então eu não consigo git push por acidente.)

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

Você tem que configurar uma chave privada SSH, você pode rever esta página , como fazer a configuração no Mac, se você estiver no linux o guia deve ser quase o mesmo, no Windows você precisaria de uma ferramenta como o MSYS .

Passo 1 –

Crie chaves SSH em seu sistema linux usando o comando abaixo

 ssh-keygen -t rsa -b 4096 -C "your_email" 

Ele pedirá a senha e o nome do arquivo (o padrão será ~ / .ssh / id_rsa, ~ / .ssh / id_rsa.pub)

Passo 2 –

Uma vez criados os arquivos, adicione a chave pública id_rsa.pub à seção ssh da conta do github.

Etapa 3 –

Na sua máquina, adicione a chave privada id_rsa ao ssh-agent usando o comando abaixo

 ssh-add ~/.ssh/id_rsa 

Passo 4 –

Agora adicione o url remoto git@github.com: user_name / repo_name.git ao seu git repo local usando o comando abaixo.

 git remote remove origin git remote add origin git@github.com:user_name/repo_name.git 

É isso aí.

Aparentemente, ao usar o TortoiseGIT no Windows, é possível criar as chaves SSH e transferi-las para o servidor GIT usando simplesmente:

 > ssh-keygen.exe > ssh-copy-id [username]@[GIT_server] 

Eu criei um repository vazio no github e depois …

 git push -u origin master 

Você precisa configurar o URL do ssh remoto como descrito acima.

Executar o comando abaixo resolveu o problema para mim.

 git config --global credential.helper wincred 

Por favor, consulte a documentação abaixo do github:

 https://help.github.com/articles/caching-your-github-password-in-git/