Eu git pushtrabalho para um repositório Git remoto.

Todo mundo pushvai me pedir para inserir usernamee password. Gostaria de evitá-lo a cada push, mas como configurar para evitá-lo?

1. Gere 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

(Funciona apenas se o programa de confirmação for capaz de usar certificados / chaves ssh públicas e privadas)

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

Aqui está uma explicação passo a passo sobre o putty gen para as etapas acima

2. Associe a chave SSH ao repositório remoto

Esta etapa varia, dependendo de como o controle remoto estiver configurado.

• Se for um repositório do GitHub e você tiver privilégios administrativos, vá para configurações e clique em 'adicionar chave SSH'. Copie o conteúdo ~/.ssh/id_rsa.pubpara o campo 'Chave'.

• Se o seu repositório for administrado por outra pessoa, dê ao administrador o seu id_rsa.pub.

• Se o seu repositório remoto for 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 seu URL remoto para um formulário que suporte SSH ¹

Se você executou as etapas acima e ainda está recebendo a solicitação de senha, verifique se o URL do repo está no formato

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

em oposição a

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

Para ver seu URL de repo, 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}

Autenticando permanentemente com repositórios Git,

Execute o seguinte comando para ativar o cache de credenciais.

$ git config credential.helper store
$ git push https://github.com/repo.git

Username for 'https://github.com': <USERNAME>
Password for 'https://USERNAME@github.com': <PASSWORD>

O uso também deve especificar o vencimento do cache ,

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

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

Nota: Auxiliar de credencial armazenando senha não criptografada no disco local.

Se você já possui suas chaves SSH configuradas e ainda recebe a solicitação de senha, verifique se o URL do repo está no formato

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

em oposição a

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

Para ver seu URL de repo, execute:

git remote show origin

Você pode alterar o URL da seguinte git remote set-urlforma:

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

Basta usar a --repoopção 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 auxiliar irá armazenar suas senhas não criptografadas no disco, protegidas apenas pelas permissões do sistema de arquivos. Se essa não é uma troca de segurança aceitável, tente git-credential-cache ou encontre um auxiliar que se integre ao armazenamento seguro fornecido pelo seu 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'

Economia segura indefinidamente (OS X e Windows)

• Se você estiver usando um Mac, o Git vem com o modo "osxkeychain" , que armazena em cache as credenciais no chaveiro seguro anexado à 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. Executando o seguinte na linha de comando irá activar esta funcionalidade: git config --global credential.helper osxkeychain. Você precisará armazenar as credenciais no Keychain usando o aplicativo Keychain também.
• Se você estiver usando o Windows, poderá instalar um auxiliar chamado "Git Credential Manager para Windows". Isso é semelhante ao auxiliar "osxkeychain" descrito acima, mas usa o Windows Credential Store para controlar informações confidenciais. 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  

A troca resolveu o problema para mim!

Passo 1 -

Crie chaves SSH no seu sistema Linux usando o comando abaixo

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

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

Passo 2 -

Após a criação dos 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 repositório git local usando o comando abaixo.

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

É isso aí.

Conecte seu cliente git ao seu armazenamento de credenciais do SO. 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?

No sistema operacional Windows, use isso em vez disso, 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 destacar algo sobre a solução mencionada 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 obter, por exemplo) Depois disso, não será necessário digitar seu nome de usuário / senha novamente.

Usei a resposta que Pavel sugeriu e funcionou para mim. Minha diferença foi fazê-lo enquanto adicionava o controle remoto da seguinte maneira:git remote add (alias) https://(name:password)@github.com/(the remote address).git

A execução do comando abaixo resolveu o problema para mim.

git config --global credential.helper wincred

Consulte a documentação abaixo do github:

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

Até onde eu sei, existem simplesmente duas maneiras seguras : ssh ou passwd criptografados usando um keystore .

SSH

1. Entre no seu github;
2. Visite: https://github.com/settings/keys ;
3. Nova chave SSH;
4. cat ~/.ssh/id_rsa.pub, cole-o lá, nomeie-o e salve-o (se você não tiver esse arquivo, gere um para si mesmo ssh-keygen -t rsa- apenas Enter para todos os prompts);
5. Vá para o seu repositório local e atualize seu controle remoto por git remote set-url origin git+ssh://git@github.com/username/reponame.git- você pode verificá-lo primeiro por git remote -v);
6. Aqui está, apenas touch t; git add t; git commit -m "test"; git pushe confirme que sim para aproveitar o mundo sem senha .

passwd ENCRYPTED usando um keystore

Se você usar git config --global credential.helper storecomo as outras pessoas mencionadas, suas senhas não criptografadas serão armazenadas em um texto simples, sob o ~/.git-credentialsqual não é seguro como parece.

Tente criptografá- lo como

sudo apt-get install libgnome-keyring-dev
sudo make --directory=/usr/share/doc/git/contrib/credential/gnome-keyring
git config --global credential.helper /usr/share/doc/git/contrib/credential/gnome-keyring/git-credential-gnome-keyring

git config --global credential.helper store

Nesse caso, você está usando https://git@github.com/username/reponame.git.

Minha solução no Windows:

1. Clique com o botão direito do mouse no diretório para pressionar e selecione "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/<your_user_name_here>/.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

Se o seu PC estiver seguro ou você não se importa com a segurança da senha, isso pode ser conseguido com muita simplicidade. Supondo que o repositório remoto esteja no GitHub e originseja seu nome local para o repositório remoto, use este comando

git remote set-url --push origin https://<username>:<password>@github.com/<repo>

O --pushsinalizador garante que isso mude a URL do repositório apenas para o git pushcomando. (A pergunta feita na postagem original é git pushapenas sobre comando. Exigir um nome de usuário + senha apenas para operações push é a configuração normal para repositórios públicos no GitHub. Observe que repositórios privados no GitHub também exigiriam um nome de usuário + senha para operações de extração e busca , portanto, para um repositório privado, você não gostaria de usar o --push flag...)

AVISO: isso é inerentemente inseguro porque:

1. seu provedor de serviços de Internet ou qualquer pessoa que acesse sua rede, pode ver facilmente a senha em texto sem formatação no URL;

2. qualquer pessoa que tenha acesso ao seu PC pode visualizar 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 obtenha acesso ao seu PC ainda pode, por exemplo, fazer empurrões que destroem seu repositório ou - pior ainda - enviar por push, fazendo alterações sutis no seu código. (Todas --amendas confirmações por push são obviamente muito visíveis no GitHub. Mas se alguém quisesse alterar seu código clandestinamente, elas poderiam fazer uma confirmação anterior sem alterar a mensagem de confirmação e depois forçá-la. Isso seria furtivo e bastante difícil de observar na prática. )

Mas revelar sua senha é pior . Se um invasor obtiver conhecimento do seu nome de usuário + senha, poderá fazer coisas como bloquear você da sua própria conta, excluir sua conta, excluir permanentemente o repositório etc.

Como alternativa - por simplicidade e segurança - você pode fornecer apenas seu nome de usuário no URL, para que você precise digitar sua senha toda vez git pushque precisar, mas não precisará fornecer seu nome de usuário todas as vezes. (Eu gosto muito dessa abordagem, ter que digitar a senha me dá uma pausa para pensar cada vez que eu git push, então não posso git pushpor acidente.)

git remote set-url --push origin https://<username>@github.com/<repo>

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 canal. Embora ele dê credential.helper, ele armazena no sistema de arquivos ou cria um daemon etc. Geralmente, as credenciais do GIT são aquelas no nível do sistema e o ônus de mantê-las seguras é no aplicativo que chama os comandos git. Muito inseguro mesmo.

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

GIT CLONE

Para a clonagem, use "git clone URL" depois de alterar a URL do 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 repositório da senha como na próxima seção.

PURGING

Agora, isso teria ido e

1. escreveu a senha na origem remota do git. Digite "git remote -v" para ver o dano. Corrija isso definindo o URL de origem remota sem senha. "origem remota set_url do git http: // {myuser} @ {my_repo_ip_address} / {myrepo_name.git}"
2. escreveu a senha em .git / logs no repositório. Substitua todas as instâncias do 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 possui barras, ele precisa ser escapado por duas barras invertidas. Por exemplo, 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ê deve usar o Runtime, use getRunTime (). Exec, que recebe o array String como argumentos com / bin / bash e -c como argumentos, em vez do que aceita um único String como argumento.

GIT FETCH / PULL / PUSH

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

Você precisa configurar uma chave privada SSH, pode revisar esta página , como fazer a instalação no Mac; se você estiver no Linux, o guia deve ser quase o mesmo; no Windows, você precisará de uma ferramenta como o MSYS .

Parece que, pelo menos 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]