Estação de Trabalho como Código (Parte 4): Organizando Acessos com SSH Config

Aprenda a organizar seus acessos remotos de forma eficiente e segura com um arquivo de configuração SSH modular. Este tutorial mostra como usar ProxyJump, múltiplos arquivos de configuração e como automatizar a criação de links simbólicos para seus dotfiles com um script Bash robusto.

Posted Feb 19, 2026

By Gean Martins

19 min read

Tutorial Anterior: Estação de Trabalho como Código (Parte 3): Configurando Vim e Tmux

Introdução

Nas partes anteriores, construímos uma base sólida para nossa estação de trabalho, personalizando o shell, o editor de texto e o multiplexador de terminal. Agora, vamos abordar um dos aspectos mais críticos para um SysAdmin: o acesso remoto. Gerenciar dezenas de servidores, cada um com seu próprio IP, usuário e chave, pode se tornar um caos. O arquivo de configuração do SSH (~/.ssh/config) é a solução para isso.

Neste tutorial, vamos aprender a criar uma estrutura de configuração SSH modular e poderosa. Vamos explorar como usar ProxyJump (bastion hosts), túneis e como separar configurações pessoais, de trabalho e de laboratório. Além disso, daremos um passo fundamental na automação do nosso ambiente, criando um script Bash inteligente para gerenciar os links simbólicos (symlinks) dos nossos dotfiles.

Objetivos desta Parte

Entender o que é SSH Config e por que usá-lo
Criar uma estrutura de configuração SSH modular usando a diretiva Include
Configurar hosts para acesso direto, ProxyJump e túneis SSH
Compreender ProxyJump e bastion hosts
Desenvolver um script Bash robusto para automatizar symlinks
Implementar boas práticas de Bash scripting
Validar que todas as configurações foram aplicadas corretamente

Pré-requisitos

Conclusão da Parte 3 desta série
Conhecimento básico de SSH e chaves de autenticação
Acesso a pelo menos um servidor remoto para testar (opcional)

A quem se destina

Este tutorial é ideal para:

SysAdmins: Que gerenciam múltiplos servidores remotos
DevOps Engineers: Que usam SSH diariamente para acesso remoto
Desenvolvedores: Que trabalham com servidores e infraestrutura
Profissionais de TI: Que querem automatizar seu ambiente

Pré-conhecimento: Conhecimento básico de SSH e chaves de autenticação é recomendado. Se você nunca usou SSH, recomendamos ler sobre SSH antes de começar.

Tempo Estimado

⏱ 50-65 minutos

Isso inclui:

Leitura e compreensão: ~10 min
Criação de diretórios: ~5 min
Criação de arquivos SSH: ~15 min
Criação do script: ~10 min
Execução e teste: ~10 min

Dica Útil: Se você quiser apenas copiar e colar, pode fazer em 30 minutos. Mas recomendamos ler e entender cada seção.

Verificando Pré-Requisitos

Antes de começar, certifique-se de que completou a Parte 3 corretamente:

Verificando o Repositório

  
# Verifique se o repositório existe
$ ls -la ~/workspace-as-code/dotfiles/

# Você deve ver:
# -rw-r--r-- .bash_aliases
# -rw-r--r-- .bash_custom
# -rw-r--r-- .vimrc
# drwxr-xr-x .vim
# -rw-r--r-- .tmux.conf

Verificando SSH

  
# Verifique se SSH está instalado
$ ssh -V

# Você deve ver algo como:
# OpenSSH_8.9p1 Ubuntu-3ubuntu0.1, OpenSSL 3.0.2 15 Feb 2023

# Verifique se tem chaves SSH
$ ls -la ~/.ssh/

# Você deve ver pelo menos:
# -rw------- id_rsa
# -rw-r--r-- id_rsa.pub

# Se não tiver, crie uma chave
$ ssh-keygen -t rsa -b 4096 -f ~/.ssh/id_rsa -N ""

Se alguma ferramenta não for encontrada, volte à Parte 1 e instale-a.

O que é SSH Config?

O arquivo ~/.ssh/config é um arquivo de configuração que permite:

Definir atalhos para hosts remotos
Especificar chaves SSH por host
Usar ProxyJump para acessar redes internas
Configurar portas customizadas
Definir opções de conexão por host

Exemplo Simples

Sem SSH Config, você faria:

  
$ ssh -i ~/.ssh/my_key -p 2222 user@example.com

Com SSH Config, você faz:

$ ssh my-server

Estrutura Básica

  
Host my-server
    HostName example.com
    User user
    IdentityFile ~/.ssh/my_key
    Port 2222

Muito mais simples! Vamos criar uma estrutura modular para gerenciar múltiplos hosts.

Preparando a Estrutura SSH

Criando os Diretórios

  
# Navegue até o diretório de dotfiles
$ cd ~/workspace-as-code/dotfiles

# Crie o diretório .ssh e config.d
$ mkdir -p .ssh/config.d

# Verifique a estrutura
$ ls -la .ssh/

# Você deve ver:
# drwxr-xr-x config.d

Entendendo a Estrutura

dotfiles/
├── .ssh/
│   ├── config              (arquivo principal)
│   └── config.d/           (configurações específicas)
│       ├── pessoal.conf
│       ├── trabalho.conf
│       └── lab.conf
├── .bash_aliases
├── .bash_custom
├── .vimrc
├── .vim/
└── .tmux.conf

Essa estrutura modular permite gerenciar configurações SSH de forma organizada e profissional.

Criando os Arquivos de Configuração SSH

Método 1: Usando cat com redirecionamento (recomendado)

  
# Crie o arquivo config principal
$ cat > ~/workspace-as-code/dotfiles/.ssh/config << 'EOF'
# ~/.ssh/config
# Configuracao principal do SSH

# Configuracoes globais
Host *
    IdentitiesOnly yes  # Evita que o SSH tente todas as chaves disponíveis
    ServerAliveInterval 60
    ServerAliveCountMax 5

# Inclui arquivos de configuracao específicos
Include ~/.ssh/config.d/pessoal.conf
Include ~/.ssh/config.d/trabalho.conf
Include ~/.ssh/config.d/lab.conf
EOF

Método 2: Usando um editor

  
$ vim ~/workspace-as-code/dotfiles/.ssh/config
# Pressione 'i' para inserir
# Cole o conteúdo
# Pressione Esc e digite ':wq' para salvar

Para este tutorial, usaremos a Método 1 (cat com redirecionamento).

Criando os Arquivos Específicos

Agora, crie os arquivos dentro de ~/workspace-as-code/dotfiles/.ssh/config.d/:

Arquivo 1: pessoal.conf

  
$ cat > ~/workspace-as-code/dotfiles/.ssh/config.d/pessoal.conf << 'EOF'
# pessoal.conf
# Configuracoes para servidores pessoais e VPS

Host vps-pessoal
    HostName 198.51.100.10
    User gean
    IdentityFile ~/.ssh/vps_key
    Port 22022

Host gitlab.com
    HostName gitlab.com
    User git
    IdentityFile ~/.ssh/gitlab_key

Host github.com
    HostName github.com
    User git
    IdentityFile ~/.ssh/github_key
EOF

Arquivo 2: trabalho.conf

  
$ cat > ~/workspace-as-code/dotfiles/.ssh/config.d/trabalho.conf << 'EOF'
# trabalho.conf
# Configuracoes para infraestrutura de trabalho

# Jump Host / Bastion
Host jump.trabalho
    HostName 203.0.113.5
    User seu_usuario
    IdentityFile ~/.ssh/trabalho_key
    Port 22

# Servidor interno acessado via Jump Host
Host servidor-interno
    HostName 10.10.1.50
    User admin
    ProxyJump jump.trabalho
    IdentityFile ~/.ssh/trabalho_key

# Outro servidor interno
Host db-server
    HostName 10.10.1.100
    User postgres
    ProxyJump jump.trabalho
    IdentityFile ~/.ssh/trabalho_key
EOF

Arquivo 3: lab.conf

  
$ cat > ~/workspace-as-code/dotfiles/.ssh/config.d/lab.conf << 'EOF'
# lab.conf
# Configuracoes para ambiente de laboratorio

Host lab-vm1
    HostName 192.168.1.100
    User ubuntu
    IdentityFile ~/.ssh/lab_key

Host lab-vm2
    HostName 192.168.1.101
    User ubuntu
    IdentityFile ~/.ssh/lab_key
EOF

Entendendo ProxyJump

ProxyJump (também chamado de bastion host ou jump host) é um servidor intermediário que você usa para acessar outros servidores em uma rede interna.

Cenário Típico

Seu Computador
    |
    | SSH
    v
Jump Host (203.0.113.5)
    |
    | SSH (rede interna)
    v
Servidor Interno (10.10.1.50)

Sem ProxyJump (forma antiga)

  
# Passo 1: Conectar ao jump host
$ ssh jump.trabalho

# Passo 2: Do jump host, conectar ao servidor interno
$ ssh servidor-interno

Com ProxyJump (forma moderna)

  
# Tudo em um comando
$ ssh servidor-interno

# O SSH automaticamente:
# 1. Conecta ao jump.trabalho
# 2. Cria um túnel para 10.10.1.50
# 3. Conecta ao servidor-interno

Configuração

  
Host jump.trabalho
    HostName 203.0.113.5
    User seu_usuario
    IdentityFile ~/.ssh/trabalho_key

Host servidor-interno
    HostName 10.10.1.50
    User admin
    ProxyJump jump.trabalho

Muito mais simples e seguro!

Exemplos de Configuração SSH

Exemplo 1: Servidor com Porta Customizada

  
Host meu-vps
    HostName 203.0.113.42
    User ubuntu
    IdentityFile ~/.ssh/vps_key
    Port 2222

Exemplo 2: Múltiplas Chaves para o Mesmo Host

  
Host github.com
    HostName github.com
    User git
    IdentityFile ~/.ssh/github_personal
    IdentityFile ~/.ssh/github_work

Exemplo 3: Servidor com Opções Customizadas

  
Host servidor-producao
    HostName prod.example.com
    User admin
    IdentityFile ~/.ssh/prod_key
    Port 22
    ServerAliveInterval 60
    ServerAliveCountMax 5
    Compression yes
    CompressionLevel 6

Exemplo 4: Rede Interna com Jump Host

  
Host jump.interno
    HostName 203.0.113.10
    User admin
    IdentityFile ~/.ssh/interno_key

Host db-server
    HostName 10.0.1.50
    User postgres
    ProxyJump jump.interno

Host web-server
    HostName 10.0.1.100
    User www-data
    ProxyJump jump.interno

Escolha os exemplos que mais se aplicam ao seu caso!

Permissões Corretas de Arquivos SSH

SSH é muito rigoroso com permissões. Arquivos com permissões erradas serão ignorados.

Permissões Esperadas

Arquivo/Diretório	Permissão	Comando
`~/.ssh/`	700 (drwx——)	`chmod 700 ~/.ssh`
`~/.ssh/config`	600 (-rw——-)	`chmod 600 ~/.ssh/config`
`~/.ssh/id_rsa`	600 (-rw——-)	`chmod 600 ~/.ssh/id_rsa`
`~/.ssh/id_rsa.pub`	644 (-rw-r–r–)	`chmod 644 ~/.ssh/id_rsa.pub`
`~/.ssh/authorized_keys`	600 (-rw——-)	`chmod 600 ~/.ssh/authorized_keys`

Corrigindo Permissões

  
# Corrija todas as permissões de uma vez
$ chmod 700 ~/.ssh
$ chmod 600 ~/.ssh/config
$ chmod 600 ~/.ssh/id_rsa
$ chmod 644 ~/.ssh/id_rsa.pub

# Verifique
$ ls -la ~/.ssh/

# Você deve ver algo como:
# drwx------ .ssh
# -rw------- config
# -rw------- id_rsa
# -rw-r--r-- id_rsa.pub

Se as permissões estiverem erradas, SSH recusará usar as chaves!

Testando a Configuração SSH

Após criar os arquivos de configuração, teste-os:

Teste 1: Verificar Sintaxe

  
# Verifique se a sintaxe está correta
$ ssh -G seu-host

# Você deve ver as configurações do host
# Se houver erro de sintaxe, será mostrado aqui

Teste 2: Conectar com Verbose

  
# Conecte com modo verbose para ver o que está acontecendo
$ ssh -v seu-host

# Você verá logs detalhados da conexão:
# debug1: Reading configuration data /home/user/.ssh/config
# debug1: Applying options for seu-host
# debug1: Authentications that can continue: publickey
# ...

Teste 3: Testar ProxyJump

  
# Se estiver usando ProxyJump, teste
$ ssh -v servidor-interno

# Você verá que primeiro conecta ao jump host:
# debug1: Executing proxy command: ssh -v jump.trabalho
# ...

Teste 4: Listar Hosts Configurados

  
# Veja todos os hosts disponíveis
$ grep "^Host " ~/.ssh/config ~/.ssh/config.d/*

# Você verá uma lista de todos os hosts:
# /home/user/.ssh/config:Host *
# /home/user/.ssh/config.d/pessoal.conf:Host vps-pessoal
# /home/user/.ssh/config.d/pessoal.conf:Host gitlab.com
# /home/user/.ssh/config.d/trabalho.conf:Host jump.trabalho
# /home/user/.ssh/config.d/trabalho.conf:Host servidor-interno

Automatizando a Configuração com um Script de Symlinks

Até agora, criamos todos os nossos dotfiles dentro de ~/workspace-as-code/dotfiles. Para que o sistema os utilize, precisamos criar links simbólicos (symlinks) deles para nosso diretório home (~). Fazer isso manualmente é tedioso e propenso a erros. Vamos automatizar!

Entendendo o Script setup_symlinks.sh

O script é robusto e segue boas práticas. Vamos entender cada seção:

Seção 1: Cabeçalho e Configurações

  
#!/bin/bash
set -euo pipefail

Linha	Significado
`#!/bin/bash`	Shebang - diz ao sistema para usar bash
`set -e`	Exit se qualquer comando falhar
`set -u`	Exit se usar variável não definida
`set -o pipefail`	Exit se qualquer comando em um pipe falhar

Seção 2: Funções de Log

  
info() { echo -e "${BLUE}[INFO]${NC} $*"; }
warn() { echo -e "${YELLOW}[WARN]${NC} $*"; }
error() { echo -e "${RED}[ERRO]${NC} $*" >&2; exit 1; }

Essas funções coloridas tornam a saída mais legível e profissional.

Seção 3: Configurações

  
DOTFILES_DIR="${DOTFILES_DIR:-$HOME/workspace-as-code/dotfiles}"
BACKUP_DIR="$HOME/dotfiles_backup_$(date +%Y%m%d_%H%M%S)"

Define diretórios e cria backup com timestamp.

Seção 4: Loop Principal

  
for item in "${items_to_link[@]}"; do
    # Verifica se existe
    # Faz backup se necessário
    # Cria link simbólico
done

Itera sobre cada item e cria links simbólicos.

Seção 5: Atualizar .bashrc

  
for file in "${BASH_FILES_TO_SOURCE[@]}"; do
    if ! grep -q "$file" "$BASHRC_FILE"; then
        # Adiciona source ao .bashrc
    fi
done

Garante que os arquivos Bash sejam carregados automaticamente.

Criando o Script com Modo Dry-Run

Crie o script ~/workspace-as-code/scripts/setup_symlinks.sh com o conteúdo abaixo:

  
$ cat > ~/workspace-as-code/scripts/setup_symlinks.sh << 'EOF'
#!/bin/bash
# setup_symlinks.sh - Cria e gerencia symlinks para os dotfiles

set -euo pipefail

# --- Processamento de Argumentos ---
DRY_RUN=false

while [[ $# -gt 0 ]]; do
    case $1 in
        --dry-run)
            DRY_RUN=true
            shift
            ;;
        *)
            echo "Opcao desconhecida: $1"
            exit 1
            ;;
    esac
done

# --- Funcoes de Log Coloridas ---
if [ -t 1 ]; then
    BLUE='\e[34m'; YELLOW='\e[33m'; RED='\e[31m'; GREEN='\e[32m'; NC='\e[0m'
else
    BLUE=''; YELLOW=''; RED=''; GREEN=''; NC=''
fi

info() { echo -e "${BLUE}[INFO]${NC} $*"; }
warn() { echo -e "${YELLOW}[WARN]${NC} $*"; }
error() { echo -e "${RED}[ERRO]${NC} $*" >&2; exit 1; }
success() { echo -e "${GREEN}[OK]${NC} $*"; }

# --- Configuracoes ---
DOTFILES_DIR="${DOTFILES_DIR:-$HOME/workspace-as-code/dotfiles}"
BACKUP_DIR="$HOME/dotfiles_backup_$(date +%Y%m%d_%H%M%S)"

# Lista de arquivos/diretorios para criar links
items_to_link=(
    ".bash_aliases" \
    ".bash_custom" \
    ".vimrc" \
    ".vim" \
    ".tmux.conf" \
    ".ssh/config" \
    ".ssh/config.d"
)

# --- Inicio do Script ---
if [ "$DRY_RUN" = true ]; then
    info "Modo DRY-RUN ativado. Nenhuma mudanca sera feita."
fi

info "Iniciando a configuracao de symlinks..."

if [ "$DRY_RUN" = false ]; then
    mkdir -p "$BACKUP_DIR"
    info "Backups serao salvos em: $BACKUP_DIR"
fi

for item in "${items_to_link[@]}"; do
    source_item="$DOTFILES_DIR/$item"
    target_item="$HOME/$item"

    # Verifica se o arquivo de origem existe
    if [ ! -e "$source_item" ]; then
        warn "Arquivo de origem nao encontrado: $source_item. Pulando."
        continue
    fi

    if [ "$DRY_RUN" = true ]; then
        info "[DRY-RUN] Seria criado link: $source_item -> $target_item"
        continue
    fi

    # Se o alvo ja existe e nao e um link, faz backup
    if [ -e "$target_item" ] && [ ! -L "$target_item" ]; then
        info "Fazendo backup de $target_item..."
        mv "$target_item" "$BACKUP_DIR/"
    fi

    # Remove link antigo, se existir
    if [ -L "$target_item" ]; then
        rm -f "$target_item"
    fi

    # Cria o diretorio pai do alvo, se nao existir
    mkdir -p "$(dirname "$target_item")"

    # Cria o novo link simbolico
    ln -s "$source_item" "$target_item"
    success "Link criado para $item"
done

# --- Atualizar .bashrc ---
BASHRC_FILE="$HOME/.bashrc"
BASH_FILES_TO_SOURCE=(".bash_aliases" ".bash_custom")

info "Verificando e atualizando .bashrc..."
for file in "${BASH_FILES_TO_SOURCE[@]}"; do
    if ! grep -q "$file" "$BASHRC_FILE"; then
        if [ "$DRY_RUN" = false ]; then
            info "Adicionando source para '$file' no .bashrc"
            echo -e "\n# Carregar $file se existir\nif [ -f \"\$HOME/$file\" ]; then\n    . \"\$HOME/$file\"\nfi" >> "$BASHRC_FILE"
        else
            info "[DRY-RUN] Seria adicionado source para '$file' no .bashrc"
        fi
    else
        info "Arquivo '$file' ja esta configurado no .bashrc"
    fi
done

if [ "$DRY_RUN" = false ]; then
    success "Configuracao concluida com sucesso!"
    echo "Execute 'source ~/.bashrc' ou reinicie seu terminal para aplicar as mudancas."
else
    info "Modo DRY-RUN concluido. Nenhuma mudanca foi feita."
fi
EOF

# Dê permissão de execução
$ chmod +x ~/workspace-as-code/scripts/setup_symlinks.sh

Executando o Script

  
# Teste em modo dry-run (sem fazer mudanças)
$ ~/workspace-as-code/scripts/setup_symlinks.sh --dry-run

# Você verá algo como:
# [INFO] Modo DRY-RUN ativado. Nenhuma mudanca sera feita.
# [INFO] Iniciando a configuracao de symlinks...
# [INFO] [DRY-RUN] Seria criado link: /home/user/workspace-as-code/dotfiles/.bash_aliases -> /home/user/.bash_aliases
# ...

# Execute o script para real
$ ~/workspace-as-code/scripts/setup_symlinks.sh

# Você verá algo como:
# [INFO] Iniciando a configuracao de symlinks...
# [INFO] Backups serao salvos em: /home/user/dotfiles_backup_20260219_143022
# [OK] Link criado para .bash_aliases
# [OK] Link criado para .bash_custom
# ...

Atenção: Este script modificará seu diretório home, criando backups de arquivos existentes. Use –dry-run primeiro para revisar o que será feito.

Troubleshooting

Se você encontrar problemas, aqui estão as soluções para os erros mais comuns:

Erro: “Permission denied (publickey)”

Problema: Você recebe esse erro ao tentar conectar via SSH.

Solução:

  
# Verifique se sua chave está sendo usada
$ ssh -v seu-host 2>&1 | grep "Trying private key"

# Verifique permissões da chave
$ ls -la ~/.ssh/id_rsa

# Deve ser 600 (rw-------)
$ chmod 600 ~/.ssh/id_rsa

# Verifique se o ssh-agent está rodando
$ ssh-add -l

# Se não estiver, adicione sua chave
$ ssh-add ~/.ssh/id_rsa

Erro: “Include not supported”

Problema: SSH antigo não suporta a diretiva Include.

Solução:

  
# Verifique sua versão do SSH
$ ssh -V

# Você precisa de OpenSSH 7.3 ou mais novo
# Se for mais antigo, combine os arquivos manualmente:
$ cat ~/.ssh/config.d/* >> ~/.ssh/config

Erro: “Host key verification failed”

Problema: SSH não consegue verificar a chave do host.

Solução:

  
# Adicione a chave do host manualmente
$ ssh-keyscan seu-host >> ~/.ssh/known_hosts

# Ou confie automaticamente (menos seguro)
$ ssh -o StrictHostKeyChecking=no seu-host

Script não cria links

Problema: O script roda, mas os links não são criados.

Solução:

  
# Execute em modo dry-run para ver o que seria feito
$ ~/workspace-as-code/scripts/setup_symlinks.sh --dry-run

# Verifique se os arquivos de origem existem
$ ls -la ~/workspace-as-code/dotfiles/

# Verifique se tem permissão
$ ls -la ~/

Permissões SSH incorretas

Problema: SSH recusa usar as chaves ou configurações.

Solução:

  
# Corrija todas as permissões
$ chmod 700 ~/.ssh
$ chmod 600 ~/.ssh/config
$ chmod 600 ~/.ssh/id_rsa
$ chmod 644 ~/.ssh/id_rsa.pub

# Verifique
$ ls -la ~/.ssh/

Validando Sua Configuração

Crie um script para validar que tudo está funcionando corretamente:

  
$ cat > ~/workspace-as-code/scripts/validate-ssh.sh << 'EOF'
#!/bin/bash
# Script para validar configuracao SSH

echo "=========================================="
echo "  Validando Configuracao SSH"
echo "=========================================="
echo ""

GREEN='\033[0;32m'
RED='\033[0;31m'
NC='\033[0m'

PASSED=0
FAILED=0

check() {
    if eval "$1" &> /dev/null; then
        echo -e "${GREEN}[OK]${NC} $2"
        ((PASSED++))
    else
        echo -e "${RED}[FAIL]${NC} $2"
        ((FAILED++))
    fi
}

# Verificar SSH
check "command -v ssh" "SSH instalado"
check "[ -d ~/.ssh ]" "Diretorio .ssh existe"
check "[ -f ~/.ssh/config ]" "Arquivo config existe"
check "[ -d ~/.ssh/config.d ]" "Diretorio config.d existe"

# Verificar chaves
check "[ -f ~/.ssh/id_rsa ]" "Chave privada existe"
check "[ -f ~/.ssh/id_rsa.pub ]" "Chave publica existe"

# Verificar permissoes
check "[ $(stat -c %a ~/.ssh 2>/dev/null || echo 000) = 700 ]" "Permissoes .ssh corretas (700)"
check "[ $(stat -c %a ~/.ssh/id_rsa 2>/dev/null || echo 000) = 600 ]" "Permissoes id_rsa corretas (600)"

# Verificar symlinks
check "[ -L ~/.vimrc ]" "Link .vimrc criado"
check "[ -L ~/.tmux.conf ]" "Link .tmux.conf criado"
check "[ -L ~/.bash_aliases ]" "Link .bash_aliases criado"

# Verificar sintaxe SSH
check "ssh -G localhost > /dev/null 2>&1" "Sintaxe SSH valida"

echo ""
echo "=========================================="
echo -e "Resultado: ${GREEN}$PASSED passou${NC}, ${RED}$FAILED falhou${NC}"
echo "=========================================="

if [ $FAILED -eq 0 ]; then
    echo "Tudo esta configurado corretamente!"
    exit 0
else
    echo "Alguns itens falharam. Revise os passos acima."
    exit 1
fi
EOF

$ chmod +x ~/workspace-as-code/scripts/validate-ssh.sh
$ ~/workspace-as-code/scripts/validate-ssh.sh

# Você deve ver algo como:
# ==========================================
#   Validando Configuracao SSH
# ==========================================
#
# [OK] SSH instalado
# [OK] Diretorio .ssh existe
# [OK] Arquivo config existe
# [OK] Diretorio config.d existe
# [OK] Chave privada existe
# [OK] Chave publica existe
# [OK] Permissoes .ssh corretas (700)
# [OK] Permissoes id_rsa corretas (600)
# [OK] Link .vimrc criado
# [OK] Link .tmux.conf criado
# [OK] Link .bash_aliases criado
# [OK] Sintaxe SSH valida
#
# ==========================================
# Resultado: 12 passou, 0 falhou
# ==========================================
# Tudo esta configurado corretamente!

Conclusão

Nesta parte, você não apenas aprendeu a organizar seus acessos SSH de maneira profissional, mas também deu um salto gigantesco na automação do seu ambiente. O script setup_symlinks.sh é uma peça central do nosso “Workspace as Code”, permitindo recriar nosso ambiente em qualquer máquina com um único comando.

O Que Você Alcançou

✓ Estrutura modular de SSH Config com Include ✓ Configuração de ProxyJump para acesso remoto seguro ✓ Exemplos práticos de múltiplas configurações SSH ✓ Script robusto de automação de symlinks ✓ Boas práticas de Bash scripting ✓ Tratamento de erros e backups automáticos ✓ Modo dry-run para testes seguros ✓ Script de validação para verificar configurações

Próximos Passos Imediatos

Crie seus arquivos de configuração SSH:

$ vim ~/workspace-as-code/dotfiles/.ssh/config.d/pessoal.conf
# Adicione seus hosts

Execute o script de setup em modo dry-run:

  
# Teste sem fazer mudanças
$ ~/workspace-as-code/scripts/setup_symlinks.sh --dry-run

Execute o script para real:

$ ~/workspace-as-code/scripts/setup_symlinks.sh

Teste a configuração SSH:

  
# Teste conexão com um host
$ ssh seu-host
   
# Valide a configuração
$ ~/workspace-as-code/scripts/validate-ssh.sh

Commit suas mudanças:

  
$ cd ~/workspace-as-code
$ git add dotfiles/.ssh/ scripts/setup_symlinks.sh scripts/validate-ssh.sh
$ git commit -m "feat: add modular ssh config and automation scripts"
$ git push origin main

Próximo Tutorial

Com a automação estabelecida, o próximo passo é explorar a customização da interface gráfica, tornando nosso ambiente de trabalho visualmente coeso e agradável.

Próximo: Estação de Trabalho como Código (Parte 4.5): Menu SSH Interativo

Recursos Adicionais

Fim da Parte 4

Próxima: Customizando o GNOME Terminal e a Interface do Ubuntu

DevOps, SysAdmin, Ubuntu

This post is licensed under CC BY 4.0 by the author.

Introdução

Objetivos desta Parte

Pré-requisitos

A quem se destina

Tempo Estimado

Verificando Pré-Requisitos

Verificando o Repositório

Verificando SSH

O que é SSH Config?

Exemplo Simples

Estrutura Básica

Preparando a Estrutura SSH

Criando os Diretórios

Entendendo a Estrutura

Criando os Arquivos de Configuração SSH

Método 1: Usando cat com redirecionamento (recomendado)

Método 2: Usando um editor

Criando os Arquivos Específicos

Entendendo ProxyJump

Cenário Típico

Sem ProxyJump (forma antiga)

Com ProxyJump (forma moderna)

Configuração

Exemplos de Configuração SSH

Exemplo 1: Servidor com Porta Customizada

Exemplo 2: Múltiplas Chaves para o Mesmo Host

Exemplo 3: Servidor com Opções Customizadas

Exemplo 4: Rede Interna com Jump Host

Permissões Corretas de Arquivos SSH

Permissões Esperadas

Corrigindo Permissões

Testando a Configuração SSH

Teste 1: Verificar Sintaxe

Teste 2: Conectar com Verbose

Teste 3: Testar ProxyJump

Teste 4: Listar Hosts Configurados

Automatizando a Configuração com um Script de Symlinks

Entendendo o Script setup_symlinks.sh

Seção 1: Cabeçalho e Configurações

Seção 2: Funções de Log

Seção 3: Configurações

Seção 4: Loop Principal

Seção 5: Atualizar .bashrc

Criando o Script com Modo Dry-Run

Executando o Script

Troubleshooting

Erro: “Permission denied (publickey)”

Erro: “Include not supported”

Erro: “Host key verification failed”

Script não cria links

Permissões SSH incorretas

Validando Sua Configuração

Conclusão

O Que Você Alcançou

Próximos Passos Imediatos

Próximo Tutorial

Recursos Adicionais

Trending Tags