Primeira hora com seu VPS: guia completo de bare metal a seguro e pronto pra usar (deixando seu OpenClaw mais seguro)

Um VPS recém-comprado é como uma porta destrancada, com script kiddies do mundo inteiro batendo nela. Este artigo te ajuda a colocar uma boa fechadura. Pra deixar seu openclaw (lagostim) quieto no canto, sem correr pra lá e pra cá.

0. Antes de começar

Você acabou de comprar um VPS, pegou o IP e a senha de root todo animado, e aí?

O que muita gente faz é: sair instalando software e subindo o projeto na hora.

Esse é um hábito perigoso.

Seu VPS tem um IP público, o que significa que qualquer pessoa no mundo pode tentar se conectar a ele. E, na configuração padrão:

• A porta exposta é a 22
• O usuário é o onipresente root
• Só te resta uma senha te protegendo

Todo dia rodam milhares de scripts automatizados escaneando faixas de IP, tentando força bruta com senhas comuns. Desde o segundo em que seu servidor fica no ar, ele já está sob ataque.

Por isso, a primeira coisa a fazer ao pegar seu VPS não é instalar software, e sim fazer a configuração de segurança inicial.

---

1. O objetivo

O objetivo deste artigo é:

• ✅ Garanta acesso remoto seguro: login por chave SSH + porta não padrão
• ✅ Crie um usuário comum: evite usar o root diretamente
• ✅ Configure o firewall: abra apenas as portas necessárias
• ✅ Ative a aceleração de rede: o BBR vai dar um gás na sua conexão
• ✅ Evite força bruta: o fail2ban bloqueia IPs maliciosos automaticamente

Com tudo isso no lugar, seu VPS vai ter uma base sólida pra você deployar qualquer serviço com tranquilidade.

---

2. Planejando

Por que fazer essas configurações?

Um VPS recém-comprado é como um apartamento recém-entregue, ainda na obra grossa:

Situação padrão	Risco	Nossa solução
Login direto com root	Privilégios altos, erro de operação tem consequências graves	Criar usuário comum + sudo
Login por senha	Pode ser alvo de força bruta	Login por chave SSH
Porta 22 padrão	Escaneado por bots	Mudar para porta não padrão
Firewall desativado	Todas as portas expostas	UFW libera só o necessário
Rede nativa	Perda de pacotes alta, latência alta	Algoritmo de controle BBR

Fluxo geral

Vamos seguir essa ordem, e eu explico o porquê de cada passo.

3. Passos de operação

3.1 Primeiro login e atualização do sistema

Pegar o IP do servidor

Depois de comprar o VPS, o provedor vai te dar:

• Endereço IP: algo como 192.168.1.100
• Porta: geralmente é 22 (alguns provedores mudam para outra porta)
• Nome de usuário: normalmente root
• Senha: uma string de caracteres gerada aleatoriamente

Conexão via SSH

Usuários de Mac / Linux: abram o terminal e digitem direto:

ssh root@你的服务器IP
# 例如：ssh [email protected]

Usuários de Windows:

• O Windows 10/11 já vem com OpenSSH nativo, então dá pra usar o comando acima direto no PowerShell ou no CMD
• Ou então usem ferramentas como Termius, MobaXterm e afins

Na primeira conexão, vai aparecer um aviso de confirmação de fingerprint:

The authenticity of host '192.168.1.100 (192.168.1.100)' can't be established.
ED25519 key fingerprint is SHA256:xxxxxxxxxxxxxxxxxxx.
Are you sure you want to continue connecting (yes/no/[fingerprint])?

É basicamente o sistema perguntando: “Não conheço essa máquina, tem certeza que quer conectar?”

Digitem yes e apertem Enter. Depois, digitem a senha (atenção: nada vai aparecer na tela enquanto você digita, isso é normal e é uma medida de segurança), e apertem Enter de novo.

Se apareceu um aviso parecido com esse, é porque o login deu certo:

Welcome to Ubuntu 24.04 LTS (GNU/Linux 6.x.x-x-generic x86_64)
...
root@hostname:~#

💡 Por que confirmar a fingerprint?

Isso serve para evitar o temido “ataque man-in-the-middle”. Na primeira conexão, você anota a fingerprint do servidor. Se ela mudar nas próximas vezes que você conectar, é um sinal de que alguém pode estar se passando pelo seu servidor.

Conhecendo seu servidor

Depois de logar, vamos dar uma olhada nas informações básicas dessa máquina:

# 查看系统版本
cat /etc/os-release

# 查看内核版本
uname -r

# 查看 CPU 核心数和型号
nproc
lscpu | grep "Model name"

# 查看内存
free -h

# 查看磁盘
df -h

Guarda essas informações, vão ser úteis quando você precisar debugar algum problema no futuro.

Atualização do sistema

Sabendo como está o servidor, a primeira coisa séria a fazer é atualizar o sistema. A imagem do sistema de um servidor novo pode ter vários meses, e nesse meio tempo provavelmente já saíram vários patches de segurança:

# 更新软件包列表 + 升级所有软件 + 清理
apt update && apt full-upgrade -y && apt autoremove -y && apt autoclean

Explicando os parâmetros:

• apt update: atualiza o índice de pacotes
• apt full-upgrade: faz o upgrade de todos os softwares, incluindo o kernel
• -y: confirma automaticamente, sem precisar digitar “yes” na mão
• apt autoremove: remove dependências que não são mais necessárias
• apt autoclean: limpa o cache dos pacotes baixados

⏱️ Esse passo pode levar alguns minutos, dependendo do volume de atualizações. Se pedir alguma confirmação no meio do caminho, basicamente é só seguir o fluxo dele.

Checando se precisa reiniciar

Depois de atualizar o kernel, geralmente é preciso reiniciar para a atualização fazer efeito:

# 检查是否需要重启
cat /var/run/reboot-required 2>/dev/null && echo ">>> 需要重启" || echo ">>> 无需重启"

Se ele avisar que precisa reiniciar:

reboot

Depois de reiniciar, você vai precisar conectar via SSH de novo.

Instalando ferramentas básicas

apt install -y sudo curl wget git vim htop tree unzip net-tools ufw fail2ban neofetch

Para que servem essas ferramentas:

Ferramenta	Uso
sudo	Permite usuários comuns rodar comandos de admin
curl / wget	Baixar arquivos
git	Controle de versão
vim	Editor de texto
htop	Monitor de processos mais bonito
tree	Mostra a estrutura de diretórios em árvore
net-tools	Ferramentas de rede (ifconfig, netstat, etc.)
ufw	Firewall simples e fácil de usar
fail2ban	Proteção contra força bruta
neofetch	Mostra informações do sistema de forma bonita

3.2 Criar um usuário não-root

Por que não usar o root direto?

O usuário root tem poder demais. Num descuido simples com o rm -rf / e já era, perdeu tudo. Para o dia a dia, o ideal é usar um usuário comum e só apelar para o sudo quando precisar de privilégios de administrador.

O lobster (openclaw) é uma verdadeira fera, imagine dar logo o root pra ele, hein?

Criando o usuário

# 创建用户（把 ittinker 换成你想要的用户名）
adduser ittinker

O sistema vai pedir para você definir uma senha e preencher alguns dados:

New password:              # 输入密码（不会显示）
Retype new password:       # 再输入一次
Full Name []:              # 可以直接回车跳过
Room Number []:            # 回车跳过
Work Phone []:             # 回车跳过
Home Phone []:             # 回车跳过
Other []:                  # 回车跳过
Is the information correct? [Y/n]   # 输入 Y 确认

Concedendo privilégios sudo

# 把用户加入 sudo 组, ittinker 换成你自己上面创建的那个用户
usermod -aG sudo ittinker

Testando para ver se funcionou:

# 切换到新用户 ittinker 换成你自己上面创建的那个用户
su - ittinker

# 测试 sudo 是否生效
sudo whoami

Se a saída for root, significa que o sudo foi configurado com sucesso.

💡 Dica de ouro

Digitando exit você volta a ser o usuário root. Nas próximas etapas, vamos continuar usando o root para fazer as configurações e, quando tudo estiver pronto, aí sim voltamos para o usuário comum.

---

3.3 Configurar login por chave SSH

Autenticação por chave vs. por senha

A autenticação por chave é bem mais segura do que usar senha:

• Senhas podem sofrer ataque de força bruta, já as chaves são praticamente impossíveis de quebrar
• Você não precisa digitar a senha toda vez, muito mais prático
• Mesmo que sua senha vaze, sem a chave privada ninguém consegue logar

Passo 1: Gerar o par de chaves na sua máquina local

Execute no seu computador (não no servidor):

# 生成 ED25519 密钥（推荐，更安全更快）
ssh-keygen -t ed25519 -C "[email protected]"

Vai aparecer a seguinte mensagem:

Enter file in which to save the key (/Users/你/.ssh/id_ed25519):

Só dá Enter para usar o caminho padrão. Aqui usamos ./ittinker , ou seja, o arquivo vai ser salvo no diretório atual com o nome ittinker

Enter passphrase (empty for no passphrase):

Você pode definir uma senha para a chave (uma camada extra de proteção) ou simplesmente dar Enter para deixar em branco.

Quando terminar a geração, você vai ver dois arquivos no diretório ~/.ssh/ (abaixo estão os nomes padrão, que é o que acontece se você só der Enter):

• id_ed25519: chave privada, jamais pode vazar!
• id_ed25519.pub: chave pública, essa vai para o servidor

💡 ed25519 vs RSA

ed25519 é o algoritmo recomendado hoje em dia, mais seguro e com chaves mais curtas que o RSA tradicional. Se o seu sistema for muito antigo e não suportar, pode usar ssh-keygen -t rsa -b 4096.

Um detalhe pequeno: a chave gerada pelo ed25519 é bem menorzinha, enquanto o arquivo do RSA é grande. Fui perguntar a IA pra entender, e o tamanho não importa, depende do algoritmo mesmo.

Passo 2: Enviar a chave pública para o servidor

Método A: Usar ssh-copy-id (recomendado)

# 在你的电脑上执行
ssh-copy-id -i ~/.ssh/id_ed25519.pub yourname@你的服务器IP

Depois de digitar a senha, a chave pública é copiada para o servidor automaticamente.

Método B: Copiar manualmente

Se o ssh-copy-id não estiver disponível, você pode fazer de forma manual:

# 1. 在你的电脑上，查看公钥内容
cat ~/.ssh/id_ed25519.pub

Copie o conteúdo gerado (um texto longo que começa com ssh-ed25519).

# 2. 在服务器上，为新用户创建 .ssh 目录, ittinker 换成你刚刚创建的用户名
mkdir -p /home/ittinker/.ssh
chmod 700 /home/ittinker/.ssh

# 3. 创建 authorized_keys 文件并粘贴公钥
vim /home/ittinker/.ssh/authorized_keys
# 按 i 进入编辑模式，粘贴公钥，按 Esc，输入 :wq 保存退出

# 4. 设置正确的权限
chmod 600 /home/ittinker/.ssh/authorized_keys
chown -R ittinker:ittinker /home/ittinker/.ssh

⚠️ Permissões são muito importantes!

O SSH é bem chato com as permissões dos arquivos:

• Diretório .ssh: 700 (só você consegue acessar)
• Arquivo authorized_keys: 600 (só você consegue ler e escrever)

Se as permissões estiverem erradas, o SSH vai se recusar a usar a chave para o login.

Passo três: testar o login por chave

Abra uma nova janela do terminal (deixe a original aberta, caso algo dê errado você ainda tem como voltar atrás) e teste o login com a chave:

ssh ittinker@你的服务器IP

Se você conseguir logar sem precisar digitar a senha, a configuração da chave foi um sucesso! 🎉

(Se você definiu uma passphrase para a sua chave privada, ele vai pedir essa senha, isso é totalmente normal)

Aqui adicionamos o parâmetro -i porque essa chave não está no caminho padrão, mas sim no diretório atual. Se não especificar, o sistema vai usar a chave padrão.

---

3.4 Reforçando a segurança do SSH

Agora que o login por chave já está funcionando, vamos deixar o SSH mais blindado:

1. Mudar a porta padrão (para evitar ser escaneado)
2. Desativar o login por senha
3. Bloquear o login direto do root

Editar o arquivo de configuração do SSH

# 备份原配置
cp /etc/ssh/sshd_config /etc/ssh/sshd_config.bak

# 编辑配置
nano /etc/ssh/sshd_config

Encontre e ajuste as configurações a seguir (algumas podem estar comentadas, é só remover o # do início):

# 修改端口（选一个 1024-65535 之间的数字）
Port 22000

# 禁止 root 登录
PermitRootLogin no

# 允许密钥登录
PubkeyAuthentication yes
AuthorizedKeysFile .ssh/authorized_keys

# 禁止密码登录（确保密钥登录测试成功后再改！）
PasswordAuthentication no

# 使用更安全的 SSH2 协议
Protocol 2

# 最大认证尝试次数
MaxAuthTries 3

# 客户端超时设置
ClientAliveInterval 300
ClientAliveCountMax 2

Salve e saia (ctrl + o).

No Nano, para salvar é ctrl + o; ele vai pedir o nome do arquivo, é só dar Enter. Para sair, ctrl + x.

Reiniciar o serviço SSH

systemctl restart sshd.service

⚠️ Aviso importante!

Não feche o terminal atual! Primeiro, teste em uma nova janela se a nova configuração permite o login normalmente:

ssh -p 22000 yourname@你的服务器IP

Se conseguir logar, aí sim pode fechar a janela antiga. Se não conseguir, você ainda pode corrigir a configuração na janela antiga.

Se você comprou um servidor leve, muito provavelmente essa porta não dá pra alterar. Já as instâncias ECS tradicionais permitem a modificação, fica a dica.

---

3.5 Configurar o firewall UFW

O UFW (Uncomplicated Firewall) é a ferramenta de firewall padrão do Ubuntu: simples de configurar, mas muito poderosa.

Configuração básica

# 设置默认策略：拒绝所有入站，允许所有出站
ufw default deny incoming
ufw default allow outgoing

# 允许 SSH（使用你设置的端口）
ufw allow 22000/tcp comment 'SSH'
ufw allow 22/tcp comment 'SSH'  # 如果是轻量服务器，还是开22端口

# 允许 HTTP 和 HTTPS
ufw allow 80/tcp comment 'HTTP'
ufw allow 443/tcp comment 'HTTPS'

Ativar o firewall

ufw enable

Ele vai exibir o aviso:

Command may disrupt existing ssh connections. Proceed with operation (y|n)?

Digite y para confirmar.

Verificar o status

ufw status verbose

23022 foi um erro de digitação meu, é só seguir conforme a sua própria situação real.

A saída será algo como:

Status: active
Logging: on (low)
Default: deny (incoming), allow (outgoing), disabled (routed)

To                         Action      From
--                         ------      ----
22000/tcp (SSH)            ALLOW IN    Anywhere
80/tcp (HTTP)              ALLOW IN    Anywhere
443/tcp (HTTPS)            ALLOW IN    Anywhere
22000/tcp (SSH (v6))       ALLOW IN    Anywhere (v6)
80/tcp (HTTP (v6))         ALLOW IN    Anywhere (v6)
443/tcp (HTTPS (v6))       ALLOW IN    Anywhere (v6)

Guia rápido de comandos

# 查看状态
ufw status

# 添加规则
ufw allow 8080/tcp

# 删除规则
ufw delete allow 8080/tcp

# 允许特定 IP 访问所有端口
ufw allow from 192.168.1.100

# 禁用防火墙（不推荐）
ufw disable

# 重置所有规则
ufw reset

---

3.6 Ativando a aceleração BBR

O BBR (Bottleneck Bandwidth and Round-trip propagation time) é um algoritmo de controle de congestionamento TCP desenvolvido pelo Google, que pode melhorar significativamente o desempenho da rede.

Ativação com um clique

# 添加 BBR 配置
echo "net.core.default_qdisc=fq" >> /etc/sysctl.conf
echo "net.ipv4.tcp_congestion_control=bbr" >> /etc/sysctl.conf

# 使配置生效
sysctl -p

Verificando se está ativado

# 查看当前拥塞控制算法
sysctl net.ipv4.tcp_congestion_control

A saída deve ser:

net.ipv4.tcp_congestion_control = bbr

# 确认 BBR 模块已加载
lsmod | grep bbr

A saída será algo como:

tcp_bbr    20480  3

💡 O efeito do BBR

Ao ativar o BBR, especialmente em ambientes com rede instável ou alta latência, você vai notar claramente:

• Downloads mais rápidos
• Operações via SSH mais fluidas
• Carregamento mais rápido das páginas

---

3.7 Configurando o fail2ban para evitar força bruta

O fail2ban monitora os logs e, ao detectar IPs com várias tentativas de login falhadas, os bane automaticamente.

Configuração básica

# 复制默认配置（不要直接修改 jail.conf）
cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local

# 编辑配置
vim /etc/fail2ban/jail.local

Encontre a seção [sshd] e garanta as seguintes configurações:

[sshd]
enabled = true
port = 22000          # 改成你的 SSH 端口
filter = sshd
logpath = /var/log/auth.log
maxretry = 3          # 最大尝试次数
bantime = 3600        # 封禁时间（秒），这里是 1 小时
findtime = 600        # 在这个时间窗口内

Iniciando o serviço

# 重启 fail2ban
systemctl restart fail2ban

# 设置开机自启
systemctl enable fail2ban

Verificando o status

# 查看 fail2ban 状态
fail2ban-client status

# 查看 SSH 监控状态
fail2ban-client status sshd

A saída será algo como:

Status for the jail: sshd
|- Filter
|  |- Currently failed: 0
|  |- Total failed:     0
|  `- File list:        /var/log/auth.log
`- Actions
   |- Currently banned: 0
   |- Total banned:     0
   `- Banned IP list:

Comandos mais usados

# 手动封禁 IP
fail2ban-client set sshd banip 1.2.3.4

# 手动解封 IP
fail2ban-client set sshd unbanip 1.2.3.4

# 查看被封禁的 IP
fail2ban-client status sshd

---

3.8 [Opcional] Gerenciar vários servidores com SSH Config

Se você tem vários servidores, digitar ssh -p 22000 user@ip toda hora é chato. Dá pra simplificar isso usando o SSH Config.

Arquivo de configuração

No seu computador local, edite o ~/.ssh/config:

vim ~/.ssh/config

Adicione a configuração:

# 第一台服务器
Host vps1
    HostName 192.168.1.100
    User yourname
    Port 22000
    IdentityFile ~/.ssh/id_ed25519

# 第二台服务器
Host vps2
    HostName 192.168.1.101
    User admin
    Port 22222
    IdentityFile ~/.ssh/id_ed25519

# 通用设置（应用于所有连接）
Host *
    ServerAliveInterval 60
    ServerAliveCountMax 3
    AddKeysToAgent yes

Como usar

Agora você pode conectar direto usando um alias:

# 连接第一台服务器
ssh vps1

# 连接第二台服务器
ssh vps2

Fim do problema de ficar decorando IP, porta e usuário!

---

3.9 [Opcional] Permitir acesso apenas do Cloudflare

Se o seu site está totalmente atrás do Cloudflare, você pode configurar o firewall para permitir apenas os IPs do Cloudflare nas portas 80/443, dando um up na segurança.

⚠️ Atenção: essa configuração exige que o seu domínio já esteja usando o CDN do Cloudflare.

Script de configuração automática

# 下载脚本
wget -O ~/.cloudflare-ufw.sh https://gist.githubusercontent.com/Xm798/12560579ce11f62027ea8da1fae37456/raw/b07ac8cfe09badf02fc70e2d8bc2da68cabbda50/cloudflare-ufw.sh

# 添加执行权限
chmod +x ~/.cloudflare-ufw.sh

# 执行脚本
~/.cloudflare-ufw.sh

O que esse script vai fazer:

1. Pegar as faixas de IP mais recentes direto do site oficial da Cloudflare
2. Adicionar regras no UFW para permitir o acesso às portas 80/443 apenas para esses IPs
3. Recarregar o UFW

Configurar atualização automática

As faixas de IP da Cloudflare podem mudar, então vamos configurar uma atualização automática semanal:

# 添加 cron 任务（每周一凌晨执行）
(crontab -l 2>/dev/null; echo "0 0 * * 1 /root/.cloudflare-ufw.sh > /dev/null 2>&1") | crontab -

---

3.10 Configurar o fuso horário

O fuso horário padrão pode ser UTC. Mude para o seu fuso local para facilitar a leitura dos logs:

# 查看当前时区
timedatectl

# 设置为上海时区（中国用户）
sudo timedatectl set-timezone Asia/Shanghai

# 验证
date

---

3.11 [Opcional] Configurar atualizações de segurança automáticas

Deixe o sistema instalar os patches de segurança sozinho e não precise mais fazer isso na mão toda hora:

# 安装自动更新工具
sudo apt install -y unattended-upgrades

# 配置
sudo dpkg-reconfigure --priority=low unattended-upgrades

Escolha “Yes” para ativar as atualizações automáticas.

💡 Esse recurso instala automaticamente as atualizações de segurança, mas não faz upgrade para uma nova versão principal, então é bem tranquilo de usar.

---

4. Resumo

Checklist de inicialização

Depois de terminar essas configurações, passe por este checklist para conferir tudo:

Item de verificação	Comando	Resultado esperado
Sistema atualizado	apt update && apt list --upgradable	Nenhum pacote para atualizar
Usuário comum pode usar sudo	sudo whoami	Saída root
Login por chave funcionando	ssh yourname@ip -p port	Login sem necessidade de senha
Login por senha desativado	grep PasswordAuth /etc/ssh/sshd_config	PasswordAuthentication no
Porta SSH alterada	grep Port /etc/ssh/sshd_config	A porta que você definiu
Firewall ativado	ufw status	Status: active
BBR ativado	sysctl net.ipv4.tcp_congestion_control	= bbr
fail2ban em execução	systemctl status fail2ban	active (running)
Fuso horário definido	timedatectl	Asia/Shanghai ou seu fuso horário
Config SSH local	cat ~/.ssh/config	Apelido do servidor configurado

Localização dos arquivos principais

/etc/ssh/sshd_config        # SSH 服务端配置
~/.ssh/authorized_keys      # 允许登录的公钥
~/.ssh/config               # 本地 SSH 客户端配置（在你电脑上）
/etc/fail2ban/jail.local    # fail2ban 配置

Melhores práticas de segurança

1. Mantenha o sistema atualizado regularmente: apt update && apt upgrade
2. Verifique os logs de login periodicamente: lastb (logins falhos), last (logins bem-sucedidos)
3. Fique de olho nos bloqueios do fail2ban
4. Faça backup dos arquivos de configuração importantes antes de modificar

---

5. Registro de problemas

Q1: Login por chave falhou, ainda pede a senha?

Possíveis causas:

1. Problema de permissão (mais comum)

   # 检查并修复权限
   chmod 700 ~/.ssh
   chmod 600 ~/.ssh/authorized_keys

2. Chave pública não foi copiada direito

   # 检查 authorized_keys 内容
   cat ~/.ssh/authorized_keys
   # 应该是一行完整的公钥，以 ssh-ed25519 或 ssh-rsa 开头

3. Interferência do SELinux (sistemas CentOS/RHEL)

   restorecon -Rv ~/.ssh

Q2: Não consegue mais conectar depois de mudar a porta?

Passos para investigar:

1. Confirme que a nova porta está liberada no firewall:

   ufw status | grep 你的端口

2. Confirme que a configuração do SSH está correta:

   grep Port /etc/ssh/sshd_config

3. Confirme que o serviço do SSH está rodando:

   systemctl status sshd

4. Se não conectar de jeito nenhum, use o VNC/console do seu provedor para entrar e arrumar.

Q2.5: Mudou a porta mas simplesmente não funcionou? (Servidores leves na nuvem)

Sintoma: Você alterou o /etc/ssh/sshd_config, reiniciou o serviço, mas a porta 22 continua ativa e a nova porta não funcionou.

Como diagnosticar:

bash

# 查看是谁在监听 22 端口
netstat -lntp | grep :22

Se a saída for algo como:

tcp  0  0.0.0.0:22  0.0.0.0:*  LISTEN  1/init

Significa que a porta 22 está sendo monitorada pelo init (PID 1), e não pelo processo do sshd.

Motivo: em alguns provedores de nuvem, o SSH das instâncias do tipo “servidor de aplicação leve” ou “instância de contêiner” é gerenciado por um proxy na camada da plataforma, então a configuração do sshd dentro do seu servidor simplesmente não entra em vigor.

Solução:

Tipo de instância	Como mudar a porta do SSH
ECS tradicional	Editar o sshd_config ✅
Servidor leve	Pode ser preciso mudar no painel da nuvem, ou talvez nem seja suportado
Instância de contêiner	Em geral, não dá para mudar

Se a sua instância não deixa mudar a porta, as outras medidas de segurança pesam ainda mais:

• ✅ Criar um usuário comum + desativar o login como root
• ✅ Login por chave SSH + desativar login por senha
• ✅ fail2ban para barrar tentativas de força bruta

Caprichando nessas medidas, sua segurança continua bem alta.

Q3: o fail2ban me bloqueou?

# 用 VNC 登录后解封
fail2ban-client set sshd unbanip 你的IP

# 把你的 IP 加入白名单，编辑 jail.local
ignoreip = 127.0.0.1/8 ::1 你的IP

Q4: depois de ativar o UFW, o site parou de abrir?

# 检查 80/443 是否开放
ufw status

# 如果没有，添加规则
ufw allow 80/tcp
ufw allow 443/tcp

Q5: ao rodar um comando, aparece que o sudo não foi encontrado?

Na instalação minimalista do Debian pode não ter sudo; instale usando o root:

apt install sudo
usermod -aG sudo ittinker

---

6. Script de inicialização com um clique (use quando já estiver craque)

Se você já dominou os passos acima, pode usar este script para inicializar rapidinho.

⚠️ Atenção: Antes de rodar o script, certifique-se de que você já tem sua chave pública SSH pronta.

#!/bin/bash
# VPS 初始化脚本
# 使用方法：以 root 身份运行

set -e

# === 配置区域（根据你的需求修改）===
NEW_USER="ittinker"           # 新用户名
NEW_SSH_PORT="22000"          # 新 SSH 端口
TIMEZONE="Asia/Shanghai"      # 时区
# =====================================

echo "=== VPS 初始化脚本 ==="
echo ""

# 1. 更新系统
echo "[1/8] 更新系统..."
apt update && apt upgrade -y

# 2. 安装基础工具
echo "[2/8] 安装基础工具..."
apt install -y sudo curl wget git vim htop tree unzip net-tools ufw fail2ban neofetch

# 3. 创建新用户
echo "[3/8] 创建用户 $NEW_USER..."
if id "$NEW_USER" &>/dev/null; then
    echo "用户已存在，跳过创建"
else
    adduser --gecos "" $NEW_USER
    usermod -aG sudo $NEW_USER
fi

# 4. 配置 SSH 目录
echo "[4/8] 配置 SSH 目录..."
mkdir -p /home/$NEW_USER/.ssh
chmod 700 /home/$NEW_USER/.ssh
touch /home/$NEW_USER/.ssh/authorized_keys
chmod 600 /home/$NEW_USER/.ssh/authorized_keys
chown -R $NEW_USER:$NEW_USER /home/$NEW_USER/.ssh

echo ""
echo ">>> 请将你的公钥粘贴到下面（粘贴后按 Ctrl+D 结束）："
cat >> /home/$NEW_USER/.ssh/authorized_keys
echo ""

# 5. 修改 SSH 配置
echo "[5/8] 修改 SSH 配置..."
cp /etc/ssh/sshd_config /etc/ssh/sshd_config.bak
sed -i "s/^#*Port .*/Port $NEW_SSH_PORT/" /etc/ssh/sshd_config
sed -i "s/^#*PermitRootLogin .*/PermitRootLogin no/" /etc/ssh/sshd_config
sed -i "s/^#*PasswordAuthentication .*/PasswordAuthentication no/" /etc/ssh/sshd_config
sed -i "s/^#*PermitEmptyPasswords .*/PermitEmptyPasswords no/" /etc/ssh/sshd_config

# 6. 配置防火墙
echo "[6/8] 配置防火墙..."
ufw default deny incoming
ufw default allow outgoing
ufw allow $NEW_SSH_PORT/tcp
ufw allow 80/tcp
ufw allow 443/tcp
echo "y" | ufw enable

# 7. 开启 BBR
echo "[7/8] 开启 BBR..."
echo "net.core.default_qdisc=fq" >> /etc/sysctl.conf
echo "net.ipv4.tcp_congestion_control=bbr" >> /etc/sysctl.conf
sysctl -p

# 8. 设置时区
echo "[8/8] 设置时区..."
timedatectl set-timezone $TIMEZONE

# 重启 SSH
systemctl restart sshd

echo ""
echo "=========================================="
echo "  ✅ 初始化完成！"
echo "=========================================="
echo ""
echo "  新 SSH 端口: $NEW_SSH_PORT"
echo "  新用户: $NEW_USER"
echo "  时区: $TIMEZONE"
echo ""
echo "  请使用以下命令登录："
echo "    ssh -p $NEW_SSH_PORT $NEW_USER@$(curl -s ifconfig.me 2>/dev/null || echo '你的IP')"
echo ""
echo "  ⚠️ 重要：请先测试新配置能否登录，再关闭当前终端！"
echo ""

---

7. Depois de tudo isso, o quanto a sua segurança melhorou?

Passo	O que foi feito	Por que é importante
Atualizar o sistema	Instalar os patches mais recentes	Corrigir vulnerabilidades conhecidas
Criar um novo usuário	Não usar mais o root diretamente	Reduzir o risco de erros de operação
Chave SSH	Usar chave no lugar de senha	Impossível de quebrar com força bruta
Trocar a porta	Fugir da padrão 22	Reduzir a chance de ser encontrado em scans
Desativar senha	Permitir login só por chave	Acabar de vez com ataques de senha
Desativar root	Root não pode logar diretamente	Aumentar a dificuldade para atacar
Firewall UFW	Abrir só as portas necessárias	Reduzir a superfície de ataque
Aceleração BBR	Otimizar a performance da rede	Melhorar a velocidade de acesso
fail2ban	Banir IPs maliciosos automaticamente	Evitar ataques contínuos

Depois de tudo isso, a segurança do seu servidor já supera a de 90% dos VPS por aí.

---

O que vem no próximo post

No próximo artigo a gente vai falar sobre o guia rápido de configuração de login por chave SSH, com mais detalhes sobre:

• Como gerar chaves em diferentes sistemas
• Gerenciamento de múltiplas chaves
• Configuração do SSH Agent
• Ajustes nos clientes SSH mais comuns

---

Última atualização deste artigo: janeiro de 2026

Série Caixa de Ferramentas do Desenvolvedor Independente — segue aí pra não perder nada!