Neste texto, detalhamos como configurar a autenticação SSH no GitLab, tanto no Ubuntu quanto no macOS. SSH é uma maneira segura de se conectar a servidores remotos sem precisar digitar sua senha toda vez que se conecta.

Apresentação

Vamos aprender como configurar a autenticação SSH no GitLab, tanto no Ubuntu quanto no macOS.

Em palavras simples: SSH é uma forma de se conectar a outro computador (ou servidor) de maneira segura e sem precisar digitar sua senha toda vez. Ele usa um sistema chamado criptografia assimétrica, que funciona com um par de chaves: uma chave pública e uma chave privada.

A ideia é como ter uma fechadura (pública) que qualquer pessoa pode instalar, mas só você tem a chave secreta (privada) que abre aquela fechadura. Isso permite autenticar sua identidade sem revelar sua senha.

Com isso, fica muito mais prático clonar repositórios, enviar código (git push), atualizar (git pull) e outras operações.

Pré-requisitos (O que você precisa)

A seguir serão apresentados os pré-requisitos (o que você precisa) para a configuração da autenticação SSH no GitLab.

Ubuntu

Primeiro, instale alguns pacotes (programas) básicos pelo terminal:

sudo apt update
sudo apt install git openssh-client xclip
  • sudo apt update → Atualiza a lista de pacotes do sistema (como uma checagem para ver o que há de novo).
  • sudo apt install git → Instala o Git, que é o sistema de controle de versões.
  • openssh-client → É o programa que permite usar o protocolo SSH.
  • xclip → Ferramenta para copiar coisas do terminal para a área de transferência.

macOS

No macOS, o Git e o SSH já vêm instalados por padrão. Para confirmar, abra o terminal e digite:

git --version
ssh -V

Se não aparecer nada ou der erro, você pode instalar via Homebrew:

brew install git

Configuração global do Git

Esses comandos informam ao Git quem é você:

git config --global user.name "Meu Nome"
git config --global user.email "email.pessoa@exemplo.com"

Onde:

  • user.name → Seu nome completo (aparecerá nos históricos de commits).
  • user.email → É o e-mail que você usa no GitLab.

Sempre que você fizer um commit, esses dados identificarão você como a pessoa autora das alterações no código.

Gerar o par de chaves SSH

Agora vamos criar as chaves.

Existem algoritmos diferentes para gerar chaves SSH. Dois bem conhecidos são:

  • RSA: Antigo, seguro, mas gera chaves grandes (2048 ou 4096 bits).
  • Ed25519: Mais moderno, recomendado, gera chaves menores, porém mais seguras e rápidas.

A melhor prática, atualmente, é usar Ed25519.

Para gerar a chave:

ssh-keygen -t ed25519 -C "email.pessoa@exemplo.com"
  • ssh-keygen → Programa que cria pares de chaves.
  • -t ed25519 → Diz qual algoritmo usar (nesse caso Ed25519).
  • -C “email…“ → Um comentário para identificar a chave (geralmente seu e-mail).

O sistema vai perguntar onde salvar a chave → pressione Enter.

Vai pedir uma passphrase (senha extra para proteger sua chave). Pode digitar uma frase longa ou deixar em branco e pressionar Enter.

Carregar a chave no ssh-agent

O ssh-agent é um “guardião” da sua chave. Ele guarda sua chave privada na memória e cuida da autenticação quando o Git precisa. Assim você não precisa digitar a passphrase sempre. É como ter um porteiro que pede a senha quando alguém tenta entrar.

No Ubuntu

Edite o arquivo ~/.bashrc ou o arquivo ~/.zshrc (dependendo do seu shell) e e adicione:

eval "$(ssh-agent -s)"            # inicia o agente
ssh-add ~/.ssh/id_ed25519       # adiciona a chave

No macOS

No macOS, o shell padrão é o Zsh e ele tem integração com o Keychain (cofre de senhas do sistema).

Edite o arquivo ~/.zshrc e e adicione:

eval "$(ssh-agent -s)" 
ssh-add --apple-use-keychain ~/.ssh/id_ed25519

A opção --apple-use-keychain faz com que o sistema guarde sua senha no Keychain, evitando repetição.

Copiar a chave pública para a área de transferência

Agora precisamos copiar a chave pública (o lado que vai para o GitLab) para a área de transferência (que é como uma “prancheta” onde você guarda coisas temporariamente no sistema operacional).

No Ubuntu

xclip -sel clip < ~/.ssh/id_ed25519.pub

Se não tiver o xclip, pode exibir o conteúdo e copiar manualmente com:

cat ~/.ssh/id_ed25519.pub
  • Depois use Shift + seta para cima até o início da linha.
  • Depois use Shift + seta para a direita para selecionar até o final (a chave é uma linha longa).
  • Depois Pressione Ctrl + Shift + C para copiar para a área de transferência.
  • Agora você pode colar no navegador com Ctrl + V.
  • Dica: no Ubuntu, muitas vezes funciona também Ctrl + Insert (copiar) e Shift + Insert (colar).

No macOS

No macOS existe o comando pbcopy, que copia direto:

pbcopy < ~/.ssh/id_ed25519.pub

Se, por algum motivo, o comando pbcopy não estiver disponível, você pode exibir a chave e copiá-la manualmente:

cat ~/.ssh/id_ed25519.pub
  • No Terminal.app, você segura a tecla Shift e usa as setas para mover o cursor.
  • Cada movimento com a seta, mantendo o Shift pressionado, vai selecionando o texto.
  • Exemplos:
    • Shift + seta para a direita → seleciona caractere por caractere.
    • Shift + seta para baixo → seleciona a linha inteira abaixo (se houvesse mais de uma).
    • Shift + seta para cima → seleciona a linha inteira que está acima da linha atual (se houvesse mais de uma).
  • Neste caso, Como a chave está em uma linha só, é preciso usar Shift + seta para a direita várias vezes até selecionar tudo.
  • Depois que a linha inteira estiver selecionada, pressione Command + C.
  • Isso envia a chave para a área de transferência do macOS.
  • No navegador, vá em Preferences → SSH Keys.
  • No campo Key, pressione Command + V para colar a chave.

Observações

  • A chave pública (id_ed25519.pub) é uma linha só, geralmente bem comprida. Tenha certeza de que selecionou do começo ao fim sem cortar nada.
  • Nunca copie a chave privada (id_ed25519 sem .pub) — apenas a pública deve ser enviada ao GitLab.
  • Se você tem dificuldades frequentes com seleção manual, prefira os comandos que já mandam a chave direto para a área de transferência:
    • Ubuntu: xclip -sel clip < ~/.ssh/id_ed25519.pub
    • macOS: pbcopy < ~/.ssh/id_ed25519.pub

Adicionar a chave ao GitLab

  • Acesse GitLab (https://gitlab.com/) ou seu GitLab corporativo, um endereço parecido com: https://gitlab.nomedaempresa.com/.
  • Pressione g seguido de p (atalho GitLab) ou vá em Preferences → SSH Keys.
  • No campo Key, cole a chave (Ctrl + V no Ubuntu, Command + V no macOS).
  • No campo Title, coloque o nome do seu dispositivo, como Ubuntu24-Parallels-M1 ou MacBook-M1.
  • No campo Expiration date, deixe em branco ou coloque uma data de expiração (vencimento da chave) futura bem distante da atual.
  • Ative o botão Add key com Enter.

Arquivo ~/.ssh/config

Esse arquivo é uma forma de automatizar a configuração para cada servidor. O que isso significa? Quer dizer que você pode definir configurações específicas para cada host (servidor), como o nome do usuário e a chave de identidade a ser usada, sem precisar especificar essas informações toda vez que se conectar.

Em outras palavras: o arquivo serve para simplificar e organizar suas conexões SSH, evitando que você precise lembrar de detalhes toda vez que se conectar.

Edite/crie o arquivo:

nano ~/.ssh/config

Onde:

  • nano: é um editor de texto que você pode usar no terminal para editar arquivos.
  • ~/.ssh/config: é o arquivo de configuração do SSH, onde você pode definir as configurações específicas para cada host.

Exemplo de configuração que você pode adicionar:

Host gitlab.nomedaempresa.com
  HostName gitlab.nomedaempresa.com
  User git
  IdentityFile ~/.ssh/id_ed25519
  IdentitiesOnly yes

Aqui estamos dizendo:

  • Quando eu me conectar ao host gitlab.nomedaempresa.com,
  • use o usuário git,
  • utilize a chave ~/.ssh/id_ed25519,
  • IdentitiesOnly yes quer dizer que apenas a chave especificada deve ser usada.

No GitLab.com oficial, (que não é o mesmo que o GitLab corporativo) o usuário deve ser git, não gitlab.

  • Pressione Ctrl + O e o nano mostrará: 
    • File Name to Write: ~/.ssh/config
    • Que quer dizer “Nome do arquivo para escrever: ~/.ssh/config”.
  • Pressione Enter para confirmar e salvar.
  • Depois pressione Ctrl + X para sair do nano.
  • Ctrl + X fecha o nano e te leva de volta ao terminal.

Testando a autenticação SSH

As configurações foram feitas, agora é hora de testar a autenticação SSH.

No GitLab corporativo

ssh -T git@gitlab.nomedaempresa.com

No GitLab.com oficial

ssh -T git@gitlab.com

Na primeira conexão:

  • Será pedido para confirmar se você confia no servidor → digite yes.
  • O GitLab ficará registrado no arquivo ~/.ssh/known_hosts.
  • Se você configurou uma passphrase, ela será pedida só na primeira vez (no macOS, o Keychain lembra para você).

Resumo

No fim das contas, configurar o SSH no GitLab é como trocar aquela porta que sempre pede a chave por uma fechadura automática: você passa a entrar rápido, sem ter que ficar digitando senha toda hora, e ainda com muito mais segurança.

Seguindo os passos que foram apresentados:

  • Instalação dos pacotes necessários.
  • Geração do par de chaves SSH.
  • Cadastro da chave pública no GitLab.
  • Teste da conexão SSH.

Faz com que tudo fique pronto para trabalhar sem preocupações. A partir daí, clonar repositórios, enviar código e puxar atualizações vira algo bem mais simples e direto.