La première heure avec ton VPS : de la bare metal à une config sécurisée et prête à l'emploi (pour sécuriser ton OpenClaw)

Un VPS tout neuf, c’est une porte ouverte. Des petits malins du monde entier viennent y frapper. Dans ce tuto, on va mettre un sacré verrou. Et faire en sorte que ton openclaw ne file pas n’importe où.

0. Avant de commencer

Tu viens de prendre un VPS, tu récupères ton IP et ton mot de passe root, super excité. Et après ?

Le réflexe de beaucoup de monde, c’est de foncer : on installe des trucs, on déploie des projets.

C’est une mauvaise habitude.

Ton VPS a une IP publique, ce qui veut dire que n’importe qui sur la planète peut essayer de s’y connecter. Et avec la config par défaut :

Le port 22 est grand ouvert
Le nom d’utilisateur est le grand classique root
Il ne te reste plus que ton mot de passe pour te protéger

Chaque jour, une tripotée de scripts automatisés scannent des plages d’IP pour tenter des attaques par force brute avec des mots de passe courants. Dès la seconde où ton serveur est en ligne, il se prend déjà des attaques.

Donc, la toute première chose à faire quand tu mets la main sur un VPS, ce n’est pas d’installer des logiciels, mais de le sécuriser de A à Z.

1. L’objectif

L’objectif de cet article, c’est de :

✅ Mettre en place un accès distant sécurisé : connexion par clé SSH + port non standard
✅ Créer un utilisateur standard : éviter de bosser directement en root
✅ Configurer le pare-feu : n’ouvrir que les ports strictement nécessaires
✅ Activer l’accélération réseau : BBR pour faire décoller le réseau
✅ Se protéger du brute force : fail2ban pour bannir automatiquement les IP malveillantes

Une fois tout ça en place, ton VPS aura une base super solide, et tu pourras y déployer tes services l’esprit tranquille.

2. Réflexion et plan

Pourquoi faire toutes ces configs ?

Un VPS tout juste acheté, c’est un peu comme un appart livré brut de décoffrage :

Config par défaut	Risque	Notre solution
Connexion directe en root	Privilèges trop élevés, une mauvaise manip et c’est la catastrophe	Créer un user standard + sudo
Connexion par mot de passe	Vulnerable au brute force	Connexion SSH par clé
Port 22 par défaut	La cible n°1 des scanners	Passer sur un port non standard
Pare-feu désactivé	Tous les ports exposés à l’air libre	UFW : on n’ouvre que le strict nécessaire
Réseau natif	Taux de perte de paquets élevé, latence importante	Algorithme de contrôle de congestion BBR

Le déroulé

VPS初始化流程

On va suivre cet ordre de marche, et je t’expliquerai à chaque étape pourquoi on fait ça.

3. Les étapes

3.1 Première connexion et mise à jour du système

Récupérer l’IP du serveur

Une fois que tu as acheté ton VPS, ton fournisseur va te filer :

Adresse IP : par exemple 192.168.1.100
Port : généralement 22 (certains fournisseurs le changent)
Nom d’utilisateur : généralement root
Mot de passe : une chaîne de caractères générée aléatoirement

VPS 服务商后台的登录信息页面

Connexion SSH

Utilisateurs Mac / Linux : ouvrez le terminal et tapez directement :

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

Utilisateurs Windows :

Windows 10/11 intègre OpenSSH, vous pouvez donc utiliser la commande ci-dessus directement dans PowerShell ou CMD
Ou utilisez des outils comme Termius, MobaXterm, etc.

Lors de la première connexion, vous verrez une invite de confirmation d’empreinte :

1
2
3

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])?

Il vous demande : « Je ne connais pas cette machine, tu es sûr de vouloir te connecter ? »

Tapez yes puis appuyez sur Entrée. Ensuite, saisissez votre mot de passe (attention : aucun caractère ne s’affiche pendant la saisie, c’est une mesure de sécurité normale), et appuyez sur Entrée.

首次 SSH 连接的完整过程，包含指纹确认

Si vous voyez une invite comme celle-ci, cela signifie que la connexion a réussi :

1
2
3

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

💡 Pourquoi vérifier l’empreinte ?

C’est pour se prémunir contre les attaques de l’homme du milieu (Man-in-the-Middle). Lors de la toute première connexion, on enregistre l’empreinte du serveur. Si jamais elle change lors d’une connexion ultérieure, ça veut dire que quelqu’un est peut-être en train d’usurper l’identité de ton serveur.

登录成功了

Faire connaissance avec ton serveur

Une fois connecté, la première étape, c’est de jeter un œil à l’état général de la machine :

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

# 查看内核版本
uname -r

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

# 查看内存
free -h

# 查看磁盘
df -h

服务器基本信息输出

Garde ces infos en tête, elles te seront utiles plus tard pour dépanner si besoin.

Mise à jour du système

Maintenant qu’on a fait le tour des infos du serveur, la première vraie chose à faire, c’est de mettre le système à jour. L’image système d’un serveur tout neuf date peut-être de quelques mois, et des correctifs de sécurité ont pu sortir depuis :

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

Explication des options :

apt update : met à jour l’index des paquets
apt full-upgrade : met à niveau tous les logiciels, noyau inclus
-y : confirmation automatique, pas besoin de taper “yes” à la main
apt autoremove : supprime les dépendances qui ne sont plus utiles
apt autoclean : nettoie le cache des paquets téléchargés

apt update 和 apt upgrade 执行过程

⏱️ Cette étape peut prendre quelques minutes, selon le nombre de mises à jour. De temps en temps, il te demandera de confirmer un truc, là tu fais juste confiance au système et tu valides.

Vérifier si un redémarrage est nécessaire

Après une mise à jour du noyau, il faut généralement redémarrer pour que ça prenne effet :

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

是否需要重启

S’il te dit qu’il faut redémarrer :

reboot

Après le redémarrage, il faudra te reconnecter en SSH.

Installer les outils usuels

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

À quoi servent ces outils :

Outil	Usage
`sudo`	Permet aux utilisateurs normaux d’exécuter des commandes admin
`curl` / `wget`	Télécharger des fichiers
`git`	Gestion de versions
`vim`	Éditeur de texte
`htop`	Un moniteur de processus plus agréable à l’œil
`tree`	Afficher l’arborescence des dossiers
`net-tools`	Outils réseau (ifconfig, netstat, etc.)
`ufw`	Un pare-feu simple et efficace
`fail2ban`	Se protéger contre le brute-force
`neofetch`	Afficher les infos système avec style

3.2 Créer un utilisateur non-root

Pourquoi ne pas utiliser root directement ?

L’utilisateur root a des pouvoirs beaucoup trop étendus. Une simple erreur de saisie avec rm -rf / et c’est la catastrophe totale. Pour ton usage au quotidien, utilise plutôt un utilisateur normal. Tu n’aura recours aux droits d’admin qu’en cas de besoin avec sudo.

Le homard (openclaw) est une vraie bête sauvage, tu n’oserais quand même pas lui filer les clés du royaume avec root, non ?

Créer l’utilisateur

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

Le système va te demander de définir un mot de passe et de remplir quelques infos :

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

adduser 创建用户的完整交互过程

Donner les droits sudo

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

On vérifie ça tout de suite :

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

# 测试 sudo 是否生效
sudo whoami

Si ça te renvoie root, c’est que sudo est bien configuré.
测试sudo

💡 Petite astuce

Tape exit pour revenir à l’utilisateur root. Pour la suite des opérations, on va continuer à configurer le serveur avec root, et on basculera sur l’utilisateur normal une fois que tout sera prêt.

3.3 Configurer la connexion par clé SSH

Authentification par clé vs par mot de passe

SSH密钥认证原理

La connexion par clé est infiniment plus sûre qu’un simple mot de passe :

Un mot de passe peut se faire cracker par force brute, une clé c’est quasiment mission impossible
Pas besoin de taper ton mot de passe à chaque connexion, c’est tellement plus pratique
Même si ton mot de passe fuite, sans la clé privée personne ne pourra se connecter

Étape 1 : Générer la paire de clés en local

Lance ça sur ton ordinateur (pas sur le serveur) :

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

Ça va te demander :

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

Fais juste Entrée pour garder le chemin par défaut. Ici on a utilisé ./ittinker, ce qui veut dire que ça va se sauvegarder dans le dossier courant, sous le nom de ittinker.

1	Enter passphrase (empty for no passphrase):

Tu peux définir un mot de passe pour ta clé (une couche de sécurité en plus), ou juste faire Entrée pour laisser vide.

本地生成 SSH 密钥的过程

Une fois la génération terminée, tu trouveras deux fichiers dans le dossier ~/.ssh/ (voici les noms par défaut, si tu as juste fait Entrée avant) :

id_ed25519 : ta clé privée, à ne surtout jamais fuiter !
id_ed25519.pub : ta clé publique, à envoyer sur le serveur

💡 ed25519 vs RSA

ed25519 est l’algo recommandé aujourd’hui : plus sécurisé et avec des clés plus courtes que le bon vieux RSA. Si ton système est trop vieux et ne le supporte pas, tu peux te rabattre sur ssh-keygen -t rsa -b 4096.

Petit détail technique : la clé générée par ed25519 est assez petite, alors que les fichiers RSA sont balèzes. J’ai demandé à une IA pour être sûr, et en fait la taille du fichier n’a pas d’importance, c’est juste lié à l’algo.

Étape 2 : Envoyer la clé publique sur le serveur

Méthode A : utiliser ssh-copy-id (recommandée)

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

Après avoir tapé ton mot de passe, la clé publique sera automatiquement copiée sur le serveur.

ssh-copy-id 执行成功

Méthode B : copier manuellement

Si ssh-copy-id ne fonctionne pas, tu peux tout à fait le faire à la main :

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

Copie le contenu affiché (une longue chaîne qui commence par 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

⚠️ Les permissions, c’est crucial !

SSH est très strict sur les permissions des fichiers :

Dossier .ssh : 700 (accessible uniquement par ton utilisateur)

Fichier authorized_keys : 600 (lecture et écriture uniquement pour ton utilisateur)

Si les permissions ne sont pas bonnes, SSH refusera tout simplement d’utiliser la clé pour se connecter.

Étape 3 : Tester la connexion par clé

Ouvre un nouveau terminal (garde l’ancien ouvert, au cas où tu ferais une fausse manip pour pouvoir rattraper le coup), et teste la connexion par clé :

1	ssh ittinker@你的服务器IP

Si tu peux te connecter sans avoir à taper ton mot de passe, c’est gagné, la clé est bien configurée ! 🎉

(Par contre, si tu as mis un passphrase sur ta clé privée, le système te le demandera, c’est tout à fait normal)
使用密钥成功登录（无需服务器密码）

Ici j’ai rajouté le paramètre -i, parce que cette clé n’est pas dans le chemin par défaut, mais bien dans le dossier courant. Si on ne le précise pas, le système va chercher la clé par défaut.

3.4 Sécuriser SSH

Maintenant que la connexion par clé fonctionne, on va passer à la sécurisation de SSH :

Changer le port par défaut (pour éviter de se faire scanner)
Désactiver la connexion par mot de passe
Interdire la connexion directe en root

Éditer le fichier de configuration SSH

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

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

修改前

Repérez et modifiez les paramètres suivants (certains sont peut-être en commentaire, retirez simplement le # au début) :

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

# 禁止 root 登录
PermitRootLogin no

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

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

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

# 最大认证尝试次数
MaxAuthTries 3

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

修改后的 sshd_config 关键配置

Sauvegardez et quittez (ctrl + o).

Sous Nano, pour sauvegarder c’est Ctrl + O. Il vous demandera le nom du fichier, faites juste Entrée. Pour quitter, c’est Ctrl + X.

Redémarrer le service SSH

1	systemctl restart sshd.service

⚠️ Attention, c’est important !

Ne fermez pas votre terminal actuel ! D’abord, testez dans une nouvelle fenêtre si la nouvelle config vous permet de vous connecter :
1
ssh -p 22000 yourname@你的服务器IP
Si ça marche, vous pouvez fermer l’ancienne fenêtre. Si vous n’arrivez pas à vous connecter, vous pouvez toujours corriger la config dans l’ancienne fenêtre.

Si vous avez pris un serveur léger, il y a de fortes chances que ce port ne puisse pas être modifié. Les ECS classiques le permettent, faites donc bien attention.

3.5 Configurer le pare-feu UFW

UFW防火墙规则

UFW (Uncomplicated Firewall) est l’outil pare-feu par défaut sur Ubuntu. Simple à configurer, mais redoutable.

Configuration de base

# 设置默认策略：拒绝所有入站，允许所有出站
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'

Activer le pare-feu

1	ufw enable

Il vous demandera :

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

Tapez y pour confirmer.

Vérifier le statut

1	ufw status verbose

ufw status 的输出结果

23022, c’est une faute de frappe de ma part, adaptez-vous juste à votre propre situation.

Ça devrait donner un truc comme ça :

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)

Aide-mémoire des commandes courantes

# 查看状态
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 Activer l’accélération BBR

BBR (Bottleneck Bandwidth and Round-trip propagation time), c’est un algorithme de contrôle de congestion TCP développé par Google. Il peut vraiment donner un coup de fouet aux performances réseau de votre serveur.

Activation en un clin d’œil

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

# 使配置生效
sysctl -p

Vérifier que c’est bien activé

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

Vous devriez obtenir :

1	net.ipv4.tcp_congestion_control = bbr

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

Un truc comme ça :

1	tcp_bbr 20480 3

💡 L’impact de BBR

Une fois BBR activé, surtout si votre connexion est instable ou que vous avez une forte latence, vous allez clairement sentir la différence :

Vos téléchargements seront bien plus rapides

Vos sessions SSH seront plus fluides

Le chargement des pages web sera beaucoup plus réactif

bbr 开启

3.7 Configurer fail2ban pour bloquer le brute-force

fail2ban, c’est l’outil parfait pour surveiller vos logs. Dès qu’il repère une IP qui rate ses identifiants à répétition, il la bannit automatiquement.

Configuration de base

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

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

Repérez la section [sshd] et assurez-vous d’avoir cette configuration :

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

fail2ban

Démarrer le service

# 重启 fail2ban
systemctl restart fail2ban

# 设置开机自启
systemctl enable fail2ban

Vérifier le statut

# 查看 fail2ban 状态
fail2ban-client status

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

fail2ban-client status sshd 的输出

Le résultat ressemble à ça :

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:

Commandes courantes

# 手动封禁 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 [Optionnel] Gérer plusieurs serveurs avec SSH Config

Si tu as plusieurs serveurs, taper ssh -p 22000 user@ip à chaque fois, c’est vite relou. Tu peux utiliser SSH Config pour simplifier tout ça.

Le fichier de configuration

Sur ton ordinateur local, édite ~/.ssh/config :

1	vim ~/.ssh/config

Ajoute la configuration suivante :

# 第一台服务器
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

Comment l’utiliser

Maintenant, tu peux te connecter directement avec l’alias :

# 连接第一台服务器
ssh vps1

# 连接第二台服务器
ssh vps2

Plus besoin de te rappeler de l’IP, du port et du nom d’utilisateur !

3.9 [Optionnel] Restreindre l’accès à Cloudflare uniquement

Si ton site est complètement derrière Cloudflare, tu peux configurer le pare-feu pour n’autoriser que les IP de Cloudflare sur les ports 80/443. Ça rajoute une bonne couche de sécurité.

⚠️ Attention : pour cette config, il faut que ton domaine soit déjà relié au CDN de Cloudflare.

Le script de configuration automatique

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

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

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

Ce script va :

Récupère les derniers blocs IP directement depuis le site officiel de Cloudflare
Ajoute des règles UFW pour autoriser uniquement ces IP à accéder aux ports 80/443
Recharge UFW

Planifier la mise à jour automatique

Les blocs IP de Cloudflare peuvent changer, alors on va automatiser la mise à jour chaque semaine :

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

3.10 Configurer le fuseau horaire

Le fuseau horaire par défaut est probablement UTC. Passe-le sur ton fuseau horaire local, c’est beaucoup plus pratique pour relire les logs :

# 查看当前时区
timedatectl

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

# 验证
date

设置时区

3.11 [Optionnel] Activer les mises à jour de sécurité automatiques

Laisse le système installer les correctifs de sécurité tout seul, ça t’évite d’avoir à le faire à la main à chaque fois :

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

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

Choisis « Yes » pour activer les mises à jour automatiques.

💡 Cette fonctionnalité installe uniquement les mises à jour de sécurité, elle ne fait pas monter de version majeure automatiquement, donc c’est plutôt safe.

4. Bilan

Checklist de fin d’initialisation

Une fois toutes ces configs en place, utilise cette checklist pour vérifier que tout est bon :

Élément à vérifier	Commande	Résultat attendu
Système à jour	`apt update && apt list --upgradable`	Aucun paquet à mettre à jour
L’utilisateur standard peut utiliser sudo	`sudo whoami`	Sortie `root`
Connexion par clé OK	`ssh yourname@ip -p port`	Connexion sans mot de passe
Connexion par mot de passe désactivée	`grep PasswordAuth /etc/ssh/sshd_config`	`PasswordAuthentication no`
Port SSH modifié	`grep Port /etc/ssh/sshd_config`	Le port que tu as défini
Pare-feu activé	`ufw status`	`Status: active`
BBR activé	`sysctl net.ipv4.tcp_congestion_control`	`= bbr`
fail2ban en cours d’exécution	`systemctl status fail2ban`	`active (running)`
Fuseau horaire configuré	`timedatectl`	Asia/Shanghai ou ton fuseau horaire
SSH Config local	`cat ~/.ssh/config`	Alias du serveur configuré

Emplacement des fichiers clés

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

Bonnes pratiques de sécurité

Mettre à jour le système régulièrement : apt update && apt upgrade
Vérifier régulièrement les logs de connexion : lastb (connexions échouées), last (connexions réussies)
Garder un œil sur les bannissements de fail2ban
Toujours sauvegarder les fichiers de configuration importants avant de les modifier

5. Journal des anomalies

Q1 : Échec de la connexion par clé, le mot de passe est toujours demandé ?

Causes possibles :

Problème de permissions (le plus courant)

1
2
3

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

Clé publique mal copiée

1
2
3

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

Interférence de SELinux (sur les systèmes CentOS/RHEL)
1
restorecon -Rv ~/.ssh

Q2 : Plus moyen de se connecter après avoir changé le port ?

Étapes de dépannage :

Vérifie que le nouveau port est bien ouvert dans le pare-feu :
1
ufw status | grep 你的端口
Vérifie que la configuration SSH est correcte :
1
grep Port /etc/ssh/sshd_config
Vérifie que le service SSH tourne bien :
1
systemctl status sshd
Si tu n’as vraiment plus aucun accès, utilise la console VNC de ton fournisseur pour te connecter et réparer ça.

Q2.5 : Le changement de port ne prend tout simplement pas effet ? (Serveurs légers du cloud)

Symptôme : tu as modifié /etc/ssh/sshd_config, mais après avoir relancé le service, le port 22 est toujours là et le nouveau port ne marche pas.

Méthode de diagnostic :

bash

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

Si tu obtiens un résultat qui ressemble à ça :

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

Cela signifie que le port 22 est surveillé par init (PID 1), et non par le processus sshd.

Pourquoi ? Chez certains hébergeurs, le SSH des « serveurs d’application légers » ou des « instances de conteneurs » passe par un proxy géré par la plateforme. Du coup, la configuration de sshd sur ton serveur n’a aucun effet.

La solution :

Type d’instance	Comment modifier le port SSH
ECS classique	Modifier sshd_config ✅
Serveur léger	Souvent à modifier depuis la console du cloud, ou pas supporté du tout
Instance de conteneur	Généralement pas modifiable

Si ton instance ne permet pas de changer le port, les autres mesures de sécurité deviennent encore plus cruciales :

✅ Créer un utilisateur standard + désactiver le login root
✅ Connexion SSH par clé + désactiver l’authentification par mot de passe
✅ fail2ban pour bloquer le brute-force

Si tu appliques tout ça correctement, ton niveau de sécurité reste excellent.

Q3 : fail2ban m’a bloqué moi-même ?

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

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

Q4 : UFW activé, et plus d’accès au site ?

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

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

Q5 : La commande indique que sudo est introuvable ?

L’installation minimale de Debian n’inclut pas toujours sudo. Installe-le en tant que root :

1 2	apt install sudo usermod -aG sudo ittinker

6. Script d’initialisation en un clic (à utiliser une fois à l’aise)

Si tu as bien en tête toutes les étapes ci-dessus, tu peux utiliser ce script pour initialiser ton serveur en un clin d’œil.

⚠️ Attention : avant de lancer le script, assure-toi d’avoir déjà ta clé publique SSH sous la main.

#!/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. Une fois tout ça en place, c’est quoi le gain de sécurité ?

Étape	Ce qu’on a fait	Pourquoi c’est important
Mettre à jour le système	Installer les derniers patchs	Corriger les failles connues
Créer un nouvel utilisateur	Ne plus utiliser root directement	Réduire le risque de mauvaises manip
Clés SSH	Remplacer les mots de passe par des clés	Impossible à cracker par force brute
Changer le port	Ne plus utiliser le port 22 par défaut	Moins de chances de se faire scanner
Désactiver le mot de passe	N’autoriser que la connexion par clé	Stop net aux attaques sur les mots de passe
Désactiver root	root ne peut plus se connecter directement	On complique la tâche des attaquants
Pare-feu UFW	N’ouvrir que les ports nécessaires	Réduire la surface d’attaque
Accélération BBR	Optimiser les perfs réseau	Booster la vitesse d’accès
fail2ban	Bannir automatiquement les IP malveillantes	Bloquer les attaques récurrentes