Simplificando Conexões com ~/.ssh/config

Nota: Este é o quinto tutorial da série sobre SSH. Se você perdeu o anterior sobre configuração avançada do servidor, pode encontrá-lo aqui: Configuração Avançada do Servidor SSH.

Até agora, em nossa jornada SSH, digitamos o comando ssh completo toda vez que queríamos nos conectar, especificando usuário, hostname, porta (se não for a padrão) e, às vezes, o caminho para a chave privada. Isso pode se tornar repetitivo e propenso a erros, especialmente quando gerenciamos múltiplas conexões com configurações diferentes.

Felizmente, o OpenSSH oferece uma solução elegante: o arquivo de configuração do cliente, localizado em ~/.ssh/config. Este arquivo permite definir apelidos (aliases) para seus hosts e associar parâmetros específicos a cada um, tornando suas conexões muito mais simples e organizadas. Além disso, ele habilita otimizações poderosas como a multiplexação.

O Básico: Criando Aliases (Host)

O arquivo ~/.ssh/config (crie-o se não existir: touch ~/.ssh/config e ajuste permissões: chmod 600 ~/.ssh/config) é organizado em blocos, cada um começando com a diretiva Host.

A diretiva Host define um apelido ou um padrão para um ou mais hosts. Todas as diretivas indentadas abaixo dela (até o próximo Host ou o final do arquivo) se aplicam às conexões que correspondem a esse apelido ou padrão.

Sintaxe Básica:

Host <apelido_ou_padrao>
    Diretiva1 Valor1
    Diretiva2 Valor2
    ...

• <apelido_ou_padrao>: Um nome curto que você usará para se referir a esta conexão (ex: servidorweb, banco_dados, kvm-server) ou um padrão com wildcards (veremos adiante).
• As diretivas indentadas definem os parâmetros para essa conexão.

Exemplo Simples:

Vamos supor que frequentemente nos conectamos ao nosso Servidor KVM (192.168.0.254) como user_kvm e, às vezes, precisamos usar a chave ~/.ssh/id_kvm.

Em vez de digitar ssh -i ~/.ssh/id_kvm user_kvm@192.168.0.254 toda vez, podemos adicionar o seguinte ao nosso ~/.ssh/config:

Host kvm-server
    HostName 192.168.0.254
    User user_kvm
    IdentityFile ~/.ssh/id_kvm
    # Port 2222 # Exemplo se a porta fosse diferente

Agora, para conectar, basta digitar:

ssh kvm-server

O cliente SSH lerá o arquivo ~/.ssh/config, encontrará o bloco Host kvm-server e aplicará automaticamente o HostName, User e IdentityFile definidos! Muito mais limpo e fácil de lembrar.

Parâmetros Comuns por Host

As diretivas que você pode usar dentro de um bloco Host são, em sua maioria, as mesmas opções de linha de comando do ssh, mas sem o hífen inicial e com a primeira letra maiúscula. Algumas das mais úteis:

• HostName <ip_ou_dns>: O endereço IP real ou nome DNS do servidor remoto. Obrigatório se o Host for um apelido.
• User <nome_usuario>: O nome de usuário a ser usado para a conexão.
• Port <numero_porta>: A porta na qual o servidor SSH está escutando (se não for a padrão 22).
• IdentityFile /caminho/para/chave_privada: Especifica qual chave privada usar para esta conexão. Você pode ter múltiplas diretivas IdentityFile se quiser tentar várias chaves.
• IdentitiesOnly yes/no: Se definido como yes, o cliente usará apenas as chaves especificadas pelas diretivas IdentityFile neste bloco ou na linha de comando (-i), e não tentará usar outras chaves padrão ou aquelas carregadas no ssh-agent. Útil para evitar oferecer chaves erradas a um servidor.
• RequestTTY yes/no/force: Controla se um pseudo-terminal deve ser alocado. Necessário para sessões interativas.
• LogLevel QUIET/FATAL/ERROR/INFO/VERBOSE/DEBUG/DEBUG1/DEBUG2/DEBUG3: Define o nível de verbosidade para esta conexão específica (equivalente às flags -v).
• ProxyJump <apelido_ou_user@host>: (Veremos mais no exemplo da arquitetura) Especifica um host intermediário (bastion/jump host) através do qual a conexão deve ser feita.

Usando Wildcards (* e ?)

A diretiva Host também aceita wildcards para aplicar configurações a múltiplos hosts:

• *: Corresponde a zero ou mais caracteres.
• ?: Corresponde a exatamente um caractere.

Exemplo:

# Configurações padrão para todos os hosts
Host *
    User meu_usuario_padrao
    # Envia keep-alives a cada 60 segundos
    ServerAliveInterval 60
    # Tenta usar estas chaves por padrão
    IdentityFile ~/.ssh/id_ed25519
    IdentityFile ~/.ssh/id_rsa

# Configurações específicas para servidores internos
Host *.interno.minhaempresa.com 192.168.1.?
    User admin_interno
    Port 2222

# Sobrescreve usuário para um host específico
Host servidor-especial.interno.minhaempresa.com
    User usuario_especial

Ordem de Leitura: O cliente SSH lê o arquivo de cima para baixo e usa a primeira ocorrência de cada parâmetro que encontrar para um host correspondente. Isso significa que configurações em blocos Host mais específicos (sem wildcards ou com padrões mais restritos) que aparecem antes no arquivo podem sobrescrever configurações de blocos mais genéricos (Host *) que aparecem depois. No entanto, a prática comum e mais clara é colocar as configurações mais genéricas (Host *) no início e as mais específicas depois, permitindo que as específicas sobrescrevam as gerais.

Otimização Poderosa: Multiplexação (ControlMaster)

Abrir uma nova conexão TCP e realizar toda a negociação SSH (troca de chaves, autenticação) a cada vez que você executa ssh, scp ou sftp para o mesmo host pode ser lento, especialmente em redes com alta latência.

A multiplexação SSH resolve isso permitindo que múltiplas sessões SSH (shells, execuções de comando, transferências de arquivos) reutilizem uma única conexão TCP mestre já estabelecida com o servidor.

Como Funciona:

1. Na primeira vez que você se conecta a um host com multiplexação habilitada, o cliente estabelece a conexão TCP e a autenticação normalmente. Esta se torna a conexão “mestre”.
2. Ele também cria um socket de controle (um arquivo especial no sistema de arquivos) associado a essa conexão mestre.
3. Nas conexões subsequentes ao mesmo host (mesmo usuário, hostname, porta), o cliente detecta o socket de controle existente e, em vez de abrir uma nova conexão TCP, ele simplesmente se conecta ao socket e reutiliza a conexão mestre já autenticada.

Benefício: Conexões subsequentes são quase instantâneas, pois pulam toda a sobrecarga da negociação TCP e SSH.

Configuração no ~/.ssh/config:

Adicione estas diretivas a um bloco Host (pode ser Host * para habilitar para todos os hosts, ou blocos específicos):

Host *
    # Habilita o modo mestre automaticamente
    ControlMaster auto
    # Define o caminho para o socket de controle
    # %r = usuário remoto, %h = hostname, %p = porta (garante sockets únicos)
    ControlPath ~/.ssh/cm-%r@%h:%p
    # Mantém a conexão mestre aberta em segundo plano por 600s (10 min) após a última sessão escrava fechar
    ControlPersist 600

• ControlMaster auto: Habilita a criação automática da conexão mestre na primeira conexão e o uso dela por conexões subsequentes.
• ControlPath ~/.ssh/cm-%r@%h:%p: Define onde criar o arquivo de socket de controle. Usar %r, %h, e %p garante que você tenha um socket único para cada combinação de usuário/host/porta, evitando conflitos. O diretório ~/.ssh/ é um local comum e seguro.
• ControlPersist <tempo_em_segundos>: (Opcional, mas muito útil) Mantém a conexão mestre ativa em segundo plano por um tempo especificado (em segundos) mesmo depois que a sessão SSH inicial (que criou a mestre) é fechada. Sem isso, a conexão mestre fecharia assim que a primeira sessão terminasse. 600 (10 minutos) é um valor razoável, mas você pode ajustar conforme sua necessidade (ou usar yes para manter indefinidamente até ser explicitamente fechada ou o sistema reiniciar).

Com essas linhas no seu ~/.ssh/config, tente conectar a um servidor, desconectar e conectar novamente. Você notará a diferença drástica na velocidade da segunda conexão!

Exemplo Prático com a Arquitetura de Referência

Vamos aplicar o que aprendemos ao cenário de arquitetura que definimos anteriormente (Estação -> KVM -> EVE-NG -> Dispositivo Simulado):

# ~/.ssh/config

# Configurações Globais (Aplicam-se a todos, exceto se sobrescritas)
Host *
    User gean # Assumindo que 'gean' é seu usuário local padrão
    # Habilitar multiplexação para todos
    ControlMaster auto
    ControlPath ~/.ssh/cm-%r@%h:%p
    ControlPersist 600
    # Tentar estas chaves por padrão
    IdentityFile ~/.ssh/id_ed25519
    IdentityFile ~/.ssh/id_rsa

# Configuração para o Servidor KVM (Bastion/Jump Host 1)
Host kvm-server
    HostName 192.168.0.254
    User user_kvm # Usuário específico no KVM
    # IdentityFile ~/.ssh/id_kvm # Descomente se usar chave específica

# Configuração para a VM EVE-NG (Acessada via KVM)
Host eve-ng-vm
    HostName 192.168.122.50 # IP da VM na rede KVM
    User user_eve # Usuário específico na VM EVE-NG
    # Diz ao SSH para usar 'kvm-server' como jump host
    ProxyJump kvm-server
    # IdentityFile ~/.ssh/id_eve # Descomente se usar chave específica

# Configuração para o Dispositivo Simulado (Acessado via EVE-NG)
Host simulated-device
    HostName 10.240.0.50 # IP do dispositivo na rede interna do EVE-NG
    User user_device # Usuário específico no dispositivo
    # Diz ao SSH para usar 'eve-ng-vm' como jump host
    # Como 'eve-ng-vm' já usa 'kvm-server' como jump host,
    # o SSH encadeará os saltos automaticamente: Estação -> KVM -> EVE-NG -> Dispositivo
    ProxyJump eve-ng-vm
    # IdentityFile ~/.ssh/id_device # Descomente se usar chave específica

Com esta configuração:

• Para conectar ao servidor KVM: ssh kvm-server
• Para conectar à VM EVE-NG (passando transparentemente pelo KVM): ssh eve-ng-vm
• Para conectar ao dispositivo simulado (passando transparentemente pelo KVM e pela VM EVE-NG): ssh simulated-device
• Para copiar um arquivo para a VM EVE-NG: scp meu_arquivo.txt eve-ng-vm:/caminho/remoto/
• Para copiar um arquivo do dispositivo simulado: scp simulated-device:/caminho/remoto/arquivo.log .

O ~/.ssh/config abstrai toda a complexidade dos saltos múltiplos (ProxyJump) e aplica as configurações corretas (usuário, hostname, chaves) e otimizações (multiplexação) automaticamente, apenas com base no apelido que você usa!

Conclusão

O arquivo ~/.ssh/config é uma ferramenta incrivelmente poderosa para qualquer pessoa que usa SSH regularmente. Ele transforma comandos longos e complexos em apelidos simples, organiza suas conexões, permite definir configurações específicas por host e habilita otimizações significativas como a multiplexação, que acelera drasticamente as conexões subsequentes.

Investir um tempo para configurar seu ~/.ssh/config adequadamente economizará muito tempo e esforço a longo prazo, além de tornar o uso do SSH mais agradável e menos propenso a erros. A combinação de aliases, ProxyJump e ControlMaster pode simplificar até mesmo os fluxos de trabalho de conexão mais complexos.

No próximo tutorial, exploraremos as ferramentas de transferência segura de arquivos sobre SSH: scp, sftp e rsync.