Eu quero usar um push e pull automaticamente no GitExtension , sem inserir meu usuário e senha em um prompt, todas as vezes.

Então, como posso salvar minhas credenciais no git?

Corre

git config --global credential.helper store

então

git pull

forneça um nome de usuário e senha e esses detalhes serão lembrados mais tarde. As credenciais são armazenadas em um arquivo no disco, com as permissões de disco "apenas legíveis / graváveis ​​pelo usuário", mas ainda em texto sem formatação.

Se você quiser alterar a senha mais tarde

git pull

Falhará, porque a senha está incorreta, o git remove o usuário + senha ofensivo do ~/.git-credentialsarquivo, agora execute novamente

git pull

para fornecer uma nova senha para que funcione como antes.

Você pode usar o git configpara habilitar o armazenamento de credenciais no git.

git config --global credential.helper store

Ao executar esse comando, na primeira vez em que você extrai ou envia do repositório remoto, você será perguntado sobre o nome de usuário e a senha.

Posteriormente, para comunicações subsequentes com o repositório remoto, você não precisará fornecer o nome de usuário e a senha.

O formato de armazenamento é um .git-credentialsarquivo armazenado em texto sem formatação.

Além disso, você pode usar outros auxiliares para o git config credential.helpercache de memória, a saber:

git config credential.helper cache <timeout>

que leva um opcional timeout parameter, determinando por quanto tempo as credenciais serão mantidas na memória. Usando o auxiliar, as credenciais nunca tocarão no disco e serão apagadas após o tempo limite especificado. O defaultvalor é900 seconds (15 minutes).

AVISO : Se você usar esse método, as senhas da sua conta git serão salvas no plaintextformato, no global .gitconfig file, por exemplo, no linux, será/home/[username]/.gitconfig

Se isso for indesejável para você, use um ssh keypara suas contas.

Método recomendado e seguro: SSH

Crie uma chave ssh Github. Vá para github.com -> Configurações -> Chaves SSH e GPG -> Nova chave SSH. Agora salve sua chave privada no seu computador.

Então, se a chave privada é salva como id_rsa no diretório ~ / .ssh / , nós a adicionamos para autenticação, da seguinte forma:

ssh-add -K ~/.ssh/id_rsa

Um método mais seguro: armazenamento em cache

Podemos usar git-credential-store para armazenar em cache nosso nome de usuário e senha por um período de tempo. Basta digitar o seguinte na sua CLI (terminal ou prompt de comando):

git config --global credential.helper cache

Você também pode definir o período de tempo limite (em segundos) da seguinte maneira:

git config --global credential.helper 'cache --timeout=3600'

Um método ainda menos seguro

O Git-credential-store também pode ser usado, mas salva as senhas no arquivo de texto sem formatação no seu disco, como tal:

git config credential.helper store

Resposta desatualizada - rápida e insegura

Isto é um método inseguro de armazenar sua senha em texto sem formatação. Se alguém ganhar o controle do seu computador, sua senha será exposta!

Você pode definir seu nome de usuário e senha assim:

git config --global user.name "your username"

git config --global user.password "your password"

Ligue o auxiliar de credenciais para que o Git salve sua senha na memória por algum tempo:

No Terminal, digite o seguinte:

# Set git to use the credential memory cache
git config --global credential.helper cache

Por padrão, o Git armazenará sua senha em cache por 15 minutos.

Para alterar o tempo limite padrão do cache de senha, digite o seguinte:

# Set the cache to timeout after 1 hour (setting is in seconds)
git config --global credential.helper 'cache --timeout=3600'

Da Ajuda do GitHub

Você pode editar o ~/.gitconfigarquivo para armazenar suas credenciais

sudo nano ~/.gitconfig

Que já deveria ter

[user]
        email = your@email.com
        user = gitUSER

Você deve adicionar na parte inferior deste arquivo.

[credential]
        helper = store

O motivo pelo qual recomendo esta opção é porque ela é global e, a qualquer momento, você precisa remover a opção e sabe para onde ir e alterá-la.

USE SOMENTE ESTA OPÇÃO NO SEU COMPUTADOR PESSOAL.

Então quando você puxa | clone | digite sua senha git, em geral, a senha será salva no ~/.git-credentialsformato

https://GITUSER:GITPASSWORD@DOMAIN.XXX

ONDE DOMAIN.XXX PODERIA SER GITHUB.COM | BITBUCKET.ORG DE OUTROS

Ver documentos

Reinicie seu terminal.

Basta colocar suas credenciais no URL assim:

https://Username: Password@github.com/myRepoDir/myRepo.git

Você pode armazená- lo assim:

git remote add myrepo https://Userna...

... exemplo para usá- lo:

git push myrepo master

Agora, é necessário listar os aliases de URL:

git remote -v

... e que o comando para excluir um deles:

git remote rm myrepo

Para configuração global, abra o terminal (de qualquer lugar) execute o seguinte:

  git config --global user.name "your username"
  git config --global user.password "your password"

Por isso, qualquer repositório Git local que você tenha em sua máquina usará essas informações.

Você pode configurar individualmente para cada repositório fazendo:

• abra o terminal na pasta de recompra.

• execute o seguinte:

  git config user.name "your username"
  git config user.password "your password"
  

Afeta apenas essa pasta (porque sua configuração é local).

Você pode usar o git-credential-store para armazenar suas senhas não criptografadas no disco, protegidas apenas pelas permissões do sistema de arquivos.

Exemplo

$ git config credential.helper store
$ git push http://example.com/repo.git
Username: <type your username>
Password: <type your password>

[several days later]
$ git push http://example.com/repo.git
[your credentials are used automatically]

Você pode verificar as credenciais armazenadas no arquivo ~/.git-credentials

Para mais informações, visite git-credential-store - Auxiliar para armazenar credenciais em disco

Você estará mais seguro se usar a autenticação SSH do que a autenticação de nome de usuário / senha.

Se você estiver usando um Mac, a autenticação do cliente SSH será integrada ao chaveiro do MacOS. Depois de criar uma chave SSH, digite no seu terminal:

ssh-add -K ~/.ssh/id_rsa

Isso adicionará a chave privada SSH ao chaveiro do MacOS. O cliente git usará ssh quando se conectar ao servidor remoto. Contanto que você tenha registrado sua chave pública ssh no servidor, você ficará bem.

Depois de revisar dezenas de posts, blogs, etc., experimentei todos os métodos, e foi isso que eu criei. Abrange tudo.

Folha de truques sobre as credenciais e os pacotes privados do DevOps Git do Vanilla

Essas são todas as formas e ferramentas pelas quais você pode autenticar com segurança o git para clonar um repositório sem um prompt de senha interativo .

• Chaves públicas SSH
  • SSH_ASKPASS
• Tokens de acesso à API
  • GIT_ASKPASS
  • .gitconfig
  • .gitconfig [credencial]
  • .git-credentials
  • .netrc
• Pacotes particulares (grátis)
  • nó / npm package.json
  • python / pip / eggs requirements.txt
  • gemas de rubi Gemfile
  • golang go.mod

A bala de prata

Quer o Just Works ™? Esta é a bala mágica de prata.

Obtenha seu token de acesso (consulte a seção na tabela de dicas, se você precisar das instruções do Github ou Gitea para isso) e defina-o em uma variável de ambiente (tanto para desenvolvimento local quanto para implantação):

MY_GIT_TOKEN=xxxxxxxxxxxxxxxx

Para o Github, copie e execute estas linhas literalmente :

git config --global url."https://api:$MY_GIT_TOKEN@github.com/".insteadOf "https://github.com/"
git config --global url."https://ssh:$MY_GIT_TOKEN@github.com/".insteadOf "ssh://git@github.com/"
git config --global url."https://git:$MY_GIT_TOKEN@github.com/".insteadOf "git@github.com:"

Parabéns, agora qualquer repositório automatizado de clonagem de ferramentas git não será obstruído por um prompt de senha, seja usando https ou qualquer estilo de ssh url.

Não está usando o Github?

Para outras plataformas (Gitea, Github, Bitbucket), basta alterar o URL. Não altere os nomes de usuário (embora arbitrários, eles são necessários para entradas de configuração distintas).

Compatibilidade

Funciona localmente no MacOS, Linux, Windows (no Bash), Docker, CircleCI, Heroku, Akkeris, etc.

Mais informações

Veja a seção ".gitconfig em vez de" da cheatsheet.

Segurança

Veja a seção "Segurança" do cheatsheet.

Nesse caso, você precisa do ajudante de credenciais do git para informar ao git para lembrar sua senha e nome de usuário do GitHub usando a seguinte linha de comando:

git config --global credential.helper wincred 

e se você estiver usando o repo usando a chave SSH, precisará da chave SSH para autenticar.

Nenhuma das respostas acima funcionou para mim. Eu continuava recebendo o seguinte toda vez que queria fetchou pull:

Enter passphrase for key '/Users/myusername/.ssh/id_rsa':

Para Macs

Consegui impedi-lo de perguntar minha senha:

1. Abra a configuração executando: vi ~/.ssh/config
2. Adicionado o seguinte: UseKeychain yes
3. Salvo e encerrado: pressione Esc e digite:wq!

Para Windows

Consegui fazê-lo funcionar usando as informações nesta stackexchange: https://unix.stackexchange.com/a/12201/348665

Além de editar o ~/.gitconfigarquivo, você pode fazer isso se perguntar:

git config --local --edit

ou

git config --global --edit

Nota para sempre usar aspas simples :

git config --local user.name 'your username'
git config --local user.password 'your password'

ou

git config --global user.name 'your username'
git config --global user.password 'your password'

Seu nome de usuário e senha podem usar alguns caracteres que quebrariam sua senha se você usar aspas duplas.

--localou --globalsignifica que os parâmetros de configuração são salvos para o projeto ou para o usuário do sistema operacional.

Apenas use

git config --global credential.helper store

e faça o git pull , ele pedirá nome de usuário e senha; a partir de agora não fornecerá nenhum prompt para nome de usuário e senha; ele armazenará os detalhes

Armazenar nome de usuário e senha em .git-credentials

.git-credentialsé onde seu nome de usuário e senha (token de acesso) são armazenados quando você executa git config --global credential.helper store, o que outras respostas sugerem e, em seguida, digite seu nome de usuário e senha ou token de acesso:

https://${username_or_access_token}:${password_or_access_token}@github.com

Portanto, para salvar o nome de usuário e a senha (token de acesso):

git config —-global credential.helper store
echo “https://${username}:${password_or_access_token}@github.com“ > ~/.git-credentials

Isso é muito útil para o robô github, por exemplo, para resolver builds automatizados em cadeia no mesmo repositório de docker , tendo regras para ramificação diferente e, em seguida, acioná-lo pressionando-opost_push prostituta no hub da janela de encaixe.

Um exemplo disso pode ser visto aqui no stackoverflow.

Uma maneira rápida de armazenar em cache credenciais git:

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

agradável e seguro

o tempo limite é em segundos.

Depois de ler o tópico na íntegra e experimentar a maioria das respostas a essa pergunta, finalmente encontrei o procedimento que funciona para mim. Quero compartilhá-lo caso alguém tenha que lidar com um caso de uso complexo, mas ainda não queira passar pelo thread completo e pelas páginas de manual gitcredentials , gitcredentials-store etc., como eu fiz.

Veja abaixo o procedimento sugiro SE você (como eu) tem que lidar com vários repositórios de vários fornecedores (gitlab, GitHub, bitbucket, etc.), utilizando várias combinações de usuário / senha diferentes. Se você em vez disso ter apenas uma única conta para trabalhar, então você pode ser melhor empregar os git config --global credential.helper storeou git config --global user.name "your username"etc. soluções que têm sido muito bem explicado nas respostas anteriores.

Minha solução:

1. auxiliar de credenciais globais não definido, caso alguma experiência anterior atrapalhe :)

> git config --global --unset credentials.helper

2. vá para o diretório raiz do seu repositório e desative o auxiliar de credenciais local (se necessário)

> cd /path/to/my/repo

> git config --unset credential.helper

3. crie um arquivo para armazenar as credenciais do seu repositório

> git config credential.helper 'store --file ~/.git_repo_credentials'

Nota : este comando cria um novo arquivo chamado ".git_repo_credentials" em seu diretório pessoal, no qual o Git armazena suas credenciais. Se você não especificar um nome de arquivo, o Git usará o padrão ".git_credentials". Nesse caso, basta emitir o seguinte comando:

> git config credential.helper store

4. defina seu nome de usuário

git config credential.*.username my_user_name

Nota : o uso de "*" geralmente é bom se seus repositórios forem do mesmo provedor (por exemplo, GitLab). Se, em vez disso, seus repositórios são hospedados por provedores diferentes, sugiro definir explicitamente o link para o provedor para cada repositório, como no exemplo a seguir (para GitLab):

git config credential.https://gitlab.com.username my_user_name

Neste ponto, se você emitir um comando exigindo suas credenciais (por exemplo git pull), será solicitada a senha correspondente a "my_user_name". Isso é necessário apenas uma vez porque o git armazena as credenciais em ".git_repo_credentials" e usa automaticamente os mesmos dados nos acessos subseqüentes.

No comentário de rifrol, no Linux Ubuntu, a partir desta resposta , veja como no Ubuntu:

sudo apt-get install libsecret-1-0 libsecret-1-dev
cd /usr/share/doc/git/contrib/credential/libsecret
sudo make
git config --global credential.helper /usr/share/doc/git/contrib/credential/libsecret/git-credential-libsecret

Algumas outras distribuições fornecem o binário para que você não precise construí-lo.

No OS X, normalmente ele é "construído" com um módulo padrão de "osxkeychain", para que você o obtenha gratuitamente.

Verifique a documentação oficial do git:

Se você usa o transporte SSH para conectar-se a controles remotos, é possível ter uma chave sem uma senha, o que permite transferir dados com segurança sem digitar seu nome de usuário e senha. No entanto, isso não é possível com os protocolos HTTP - toda conexão precisa de um nome de usuário e senha. Isso fica ainda mais difícil para sistemas com autenticação de dois fatores, nos quais o token usado para uma senha é gerado aleatoriamente e é impronunciável.

Felizmente, o Git tem um sistema de credenciais que pode ajudar com isso. O Git tem algumas opções fornecidas na caixa:

• O padrão é não armazenar em cache. Toda conexão solicitará seu nome de usuário e senha.

• O modo "cache" mantém as credenciais na memória por um determinado período de tempo. Nenhuma das senhas é armazenada no disco e é removida do cache após 15 minutos.

• O modo "armazenamento" salva as credenciais em um arquivo de texto sem formatação no disco e elas nunca expiram. Isso significa que, até que você altere sua senha do host Git, você nunca precisará digitar suas credenciais novamente. A desvantagem dessa abordagem é que suas senhas são armazenadas em texto não criptografado em um arquivo simples em seu diretório pessoal.

• 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.

• 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 .

Você pode escolher um destes métodos, definindo um valor de configuração do Git:

$ git config --global credential.helper cache

$ git config --global credential.helper store

https://git-scm.com/book/en/v2/Git-Tools-Credential-Storage