Een verse VPS is als een deur zonder slot, waar scriptkiddies over de hele wereld op staan te kloppen. In dit artikel help ik je om die deur goed op slot te doen. Zodat je ‘openclaw’ niet zomaar over straat rondzwiert.

0. Even vooraf

Net een VPS gekocht, vol enthousiasme je IP en root-wachtwoord binnengehaald, en dan?

Wat veel mensen doen: direct aan de slag met software installeren en projecten deployen.

Dat is een gevaarlijke gewoonte.

Je VPS heeft een publiek IP, wat betekent dat iedereen ter wereld kan proberen er verbinding mee te maken. En in de standaardconfiguratie is dit het geval:

  • Poort 22 staat open
  • De gebruikersnaam is het alom bekende root
  • Er staat nog maar één wachtwoord tussen jou en de boosdoeners

Elke dag scannen talloze geautomatiseerde scripts IP-reeks om met bekende wachtwoorden brute-force aanvallen uit te voeren. Vanaf het moment dat je server live gaat, is deze al onder vuur.

Dus, het allereerste wat je moet doen zodra je een VPS hebt, is niet direct software installeren, maar de boel beveiligen.

1. Wat we gaan bereiken

Het doel van dit artikel is:

  • ✅ Krijg veilige toegang op afstand voor elkaar: inloggen met SSH-keys + een niet-standaard poort
  • ✅ Maak een gewone gebruiker aan: niet direct als root werken
  • ✅ Stel een firewall in: alleen de poorten openen die je écht nodig hebt
  • ✅ Zet netwerkversnelling aan: met BBR vliegt je verbinding door de lucht
  • ✅ Voorkom brute-force aanvallen: fail2ban bant kwaadwillende IP’s automatisch

Heb je dit allemaal gedaan? Dan staat je VPS op een rotsvaste basis en kun je er gerust allerlei diensten op gaan uitrollen.

2. Planning en bedenkingen

Waarom zou je dit allemaal doen?

Een VPS die je net hebt gekocht is eigenlijk net een kaal, onafgebouwd huis:

Standaardinstelling Risico Onze oplossing
Direct inloggen als root Te veel rechten, risico op fatale fouten Een gewone gebruiker aanmaken + sudo
Inloggen met wachtwoord Kwetsbaar voor brute-force aanvallen Inloggen via SSH-sleutel
Standaardpoort 22 Eerst doelwit voor scanners Overschakelen naar een niet-standaardpoort
Firewall uit Alle poorten blootgesteld aan buiten UFW alleen essentiële poorten openen
Standaard netwerk Hoog pakketverlies, hoge latency BBR-congestiecontrolealgoritme

Het globale overzicht

VPS初始化流程

We gaan in deze volgorde aan de slag, en bij elke stap leg ik uit waarom we het zo doen.

3. Stappenplan

3.1 Eerste keer inloggen en systeem updaten

Server-IP achterhalen

Nadat je een VPS hebt gekocht, krijg je van de provider:

  • IP-adres: zoiets als 192.168.1.100
  • Poort: meestal 22 (sommige providers gebruiken een andere poort)
  • Gebruikersnaam: meestal root
  • Wachtwoord: een willekeurig gegenereerde tekenreeks

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

Verbinding maken via SSH

Mac / Linux-gebruikers: open je terminal en typ direct:

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

Windows-gebruikers:

  • Windows 10/11 heeft OpenSSH ingebouwd, dus je kunt het bovenstaande commando direct in PowerShell of CMD gebruiken
  • Of gebruik tools zoals Termius of MobaXterm

Bij de eerste verbinding krijg je een prompt om de fingerprint te bevestigen:

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

Dit vraagt eigenlijk: “Ik ken deze machine niet, weet je zeker dat je wilt verbinden?”

Typ yes en druk op Enter. Typ daarna je wachtwoord (let op: tijdens het typen worden er geen tekens weergegeven, dit is een normale beveiligingsfunctie) en druk op Enter.

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

Als je een prompt ziet die hierop lijkt, is het je gelukt om in te loggen:

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

💡 Waarom zou je de fingerprint controleren?

Dit is om “man-in-the-middle-aanvallen” te voorkomen. De eerste keer dat je verbinding maakt, sla je de fingerprint van de server op. Als de fingerprint bij een latere verbinding opeens anders is, betekent dit dat iemand zich mogelijk als jouw server voordoet.

登录成功了

Maak even kennis met je server

Zodra je bent ingelogd, is het handig om eerst even te kijken hoe deze machine in elkaar zit:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 查看系统版本
cat /etc/os-release

# 查看内核版本
uname -r

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

# 查看内存
free -h

# 查看磁盘
df -h

服务器基本信息输出

Onthoud deze informatie, want daar ga je later naar terugkijken als je problemen moet opsporen.

Systeem updaten

Nu je de serverinfo hebt bekeken, is het eerste klusje het systeem updaten. De image van een nieuwe server is mogelijk al een paar maanden oud, en ondertussen kunnen er best al beveiligingspatches zijn uitgebracht:

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

Wat deze parameters doen:

  • apt update: de pakketindex bijwerken
  • apt full-upgrade: alle software upgraden, inclusief de kernel
  • -y: automatisch bevestigen, zodat je niet handmatig “yes” hoeft in te typen
  • apt autoremove: afhankelijkheden die niet meer nodig zijn verwijderen
  • apt autoclean: de cache met gedownloade pakketten opruimen

apt update 和 apt upgrade 执行过程

⏱️ Deze stap kan een paar minuten duren, afhankelijk van hoeveel updates er zijn. Af en toe moet je tussendoor iets bevestigen; volg gewoon de prompts en je bent goed.

Controleren of een herstart nodig is

Na een kernel-update is een herstart meestal nodig voordat deze actief wordt:

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

是否需要重启

Als er wordt aangegeven dat je moet herstarten:

1
reboot

Na de herstart moet je opnieuw via SSH verbinding maken.

Handige tools installeren

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

Waar deze tools voor dienen:

Tool Doel
sudo Gewone gebruikers beheerderscommando’s laten uitvoeren
curl / wget Bestanden downloaden
git Versiebeheer
vim Teksteditor
htop Mooiere weergave van processen
tree Mapstructuur als boomweergave
net-tools Netwerktools (ifconfig, netstat, enz.)
ufw Simpele, gebruiksvriendelijke firewall
fail2ban Bescherming tegen brute-force aanvallen
neofetch Systeeminformatie mooi weergeven
neofetch 显示的系统信息

3.2 Een niet-root gebruiker aanmaken

Waarom niet gewoon direct root gebruiken?

De root-gebruiker heeft veel te veel rechten. Eén kleine vergissing en rm -rf / is alles weg. Voor je dagelijkse dingetjes gebruik je gewoon een gewone gebruiker; als je even admin-rechten nodig hebt, gebruik je sudo.

Een kreeft (openclaw) is echt een beest, hoe durf je die root-rechten zomaar af te staan?

Gebruiker aanmaken

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

Het systeem vraagt je nu om een wachtwoord in te stellen en wat extra info in te vullen:

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

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

Sudo-rechten verlenen

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

Even controleren:

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

# 测试 sudo 是否生效
sudo whoami

Als de output root is, is je sudo-config succesvol geregeld.
测试sudo

💡 Handige tip

Met exit ga je weer terug naar de root-gebruiker. Voor de volgende stappen blijven we even root om alles in te stellen, en zodra dat klaar is, schakelen we weer over naar de gewone gebruiker.

3.3 SSH-sleutels instellen voor inloggen

Sleutelauthenticatie vs. wachtwoordauthenticatie

SSH密钥认证原理

Inloggen met een sleutel is véél veiliger dan met een wachtwoord:

  • Een wachtwoord kan je brute-forcen, een sleutel vrijwel niet
  • Je hoeft niet elke keer je wachtwoord in te tikken, makkelijker dus
  • Zelfs als je wachtwoord lekt, kom je er niet in zonder de private sleutel

Stap 1: Lokaal een sleutelpaar genereren

Voer dit uit op je eigen computer (dus niet op de server):

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

Je krijgt dan deze prompt te zien:

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

Druk gewoon op Enter om het standaardpad te gebruiken. Wij gebruiken hier ./ittinker, wat simpelweg betekent dat het bestand ittinker in de huidige map wordt opgeslagen.

1
Enter passphrase (empty for no passphrase):

Je kunt een wachtwoord voor je key instellen (een extra beveiligingslaag), of gewoon op Enter drukken om hem leeg te laten.

本地生成 SSH 密钥的过程

Als het genereren klaar is, zie je twee bestanden in de map ~/.ssh/ (dit zijn de standaardnamen als je steeds op Enter hebt gedrukt):

  • id_ed25519: de private key. Laat deze absoluut nooit uitlekken!
  • id_ed25519.pub: de public key. Deze moet je naar de server uploaden.

💡 ed25519 vs RSA

ed25519 is momenteel het aanbevolen algoritme. Het is veiliger en de key is korter dan de traditionele RSA. Als je systeem te oud is en het niet ondersteunt, kun je ssh-keygen -t rsa -b 4096 gebruiken.

Klein detail: een ed25519-key is best compact, terwijl een RSA-bestand veel groter is. Ik moest het aan AI vragen, maar blijkbaar maakt de grootte niet uit; dat ligt gewoon aan het algoritme.

Stap 2: Upload de public key naar de server

Methode A: Gebruik ssh-copy-id (aanbevolen)

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

Nadat je het wachtwoord hebt ingevoerd, wordt de public key automatisch naar de server gekopieerd.

ssh-copy-id 执行成功

Methode B: Handmatig kopiëren

Als ssh-copy-id niet werkt, kun je het ook gewoon handmatig doen:

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

Kopieer de output (een lange tekst die begint met ssh-ed25519).

1
2
3
4
5
6
7
8
9
10
11
# 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

⚠️ Permissies zijn superbelangrijk!

SSH is best streng als het om bestandsrechten gaat:

  • .ssh map: 700 (alleen jijzelf mag erbij)
  • authorized_keys bestand: 600 (alleen jijzelf mag lezen en schrijven)

Kloppen de rechten niet? Dan weigert SSH de key te gebruiken en kun je er niet mee inloggen.

Stap 3: Test je key-login

Open een nieuw terminalvenster (laat het oude venster open, voor het geval je iets verkeerd hebt ingesteld en nog even terug kunt), en test de key-login:

1
ssh ittinker@你的服务器IP

Lukt het om in te loggen zonder dat je een wachtwoord hoeft in te typen? Dan is je key succesvol ingesteld! 🎉

(Heb je een passphrase voor je private key ingesteld? Dan vraagt hij om dat wachtwoord in te typen. Heel normaal, geen zorgen.)
使用密钥成功登录（无需服务器密码）

We hebben hier een -i parameter toegevoegd, omdat we deze key niet in het standaardpad hebben staan, maar in de huidige map. Als je dat niet expliciet aangeeft, pakt het systeem namelijk de standaardkey.

3.4 SSH beveiliging aanscherpen

Nu key-login werkt, gaan we SSH nog wat verder beveiligen:

  1. Verander de standaardpoort (zo voorkom je dat je constant gescand wordt)
  2. Zet wachtwoord-login uit
  3. Verbied directe root-login

SSH-configuratiebestand aanpassen

1
2
3
4
5
# 备份原配置
cp /etc/ssh/sshd_config /etc/ssh/sshd_config.bak

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

修改前

Zoek de volgende instellingen op en pas ze aan (sommige staan mogelijk uit als commentaar, haal dan de # aan het begin weg):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 修改端口（选一个 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 关键配置

Opslaan en afsluiten (ctrl + o).

In Nano sla je op met ctrl + o. Hij vraagt dan om de bestandsnaam, gewoon op Enter drukken. Afsluiten doe je met ctrl + x.

SSH-service herstarten

1
systemctl restart sshd.service

⚠️ Belangrijke waarschuwing!

Sluit je huidige terminal nog niet! Test eerst in een nieuw venster of je met de nieuwe instellingen gewoon kunt inloggen:

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

Lukt dat? Dan kun je het oude venster veilig sluiten. Kun je er niet in? Dan kun je de configuratie in het oude venster nog herstellen.

Als je een lichte server hebt aangeschaft, is de kans groot dat je deze poort niet kunt aanpassen. Bij een traditionele ECS lukt dat wel, dus let daar even op.

3.5 UFW-firewall instellen

UFW防火墙规则

UFW (Uncomplicated Firewall) is de standaard firewall-tool van Ubuntu. Makkelijk in te stellen, maar toch behoorlijk krachtig.

Basisconfiguratie

1
2
3
4
5
6
7
8
9
10
11
# 设置默认策略：拒绝所有入站，允许所有出站
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'

Firewall inschakelen

1
ufw enable

Je krijgt dan de volgende melding:

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

Typ y om te bevestigen.

Status controleren

1
ufw status verbose

ufw status 的输出结果

23022 was een typo van mij, pas het gewoon aan naar je eigen situatie

Output zoiets:

1
2
3
4
5
6
7
8
9
10
11
12
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)

Handige commando’s snelgids

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 查看状态
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 BBR-versnelling aanzetten

BBR (Bottleneck Bandwidth and Round-trip propagation time) is een TCP-congestiecontrole-algoritme dat door Google is ontwikkeld. Het kan je netwerkprestaties aanzienlijk verbeteren.

Met één klik aanzetten

1
2
3
4
5
6
# 添加 BBR 配置
echo "net.core.default_qdisc=fq" >> /etc/sysctl.conf
echo "net.ipv4.tcp_congestion_control=bbr" >> /etc/sysctl.conf

# 使配置生效
sysctl -p

Controleren of het aan staat

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

De output zou dit moeten zijn:

1
net.ipv4.tcp_congestion_control = bbr
1
2
# 确认 BBR 模块已加载
lsmod | grep bbr

Output zoiets:

1
tcp_bbr    20480  3

💡 Het effect van BBR

Nadat je BBR hebt aangezet, merk je vooral in instabiele netwerkomgevingen of bij hoge latency duidelijk dat:

  • Downloads sneller zijn
  • SSH-operaties soepeler verlopen
  • Webpagina’s sneller laden

bbr 开启

3.7 fail2ban instellen tegen brute-force aanvallen

fail2ban houdt je logs in de gaten en blokkeert automatisch IP-adressen die meerdere keren proberen in te loggen zonder succes.

Basisconfiguratie

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

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

Zoek het [sshd] gedeelte op en zorg dat de volgende instellingen kloppen:

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

fail2ban

Start de services

1
2
3
4
5
# 重启 fail2ban
systemctl restart fail2ban

# 设置开机自启
systemctl enable fail2ban

Check de status

1
2
3
4
5
# 查看 fail2ban 状态
fail2ban-client status

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

fail2ban-client status sshd 的输出

De output ziet er ongeveer zo uit:

1
2
3
4
5
6
7
8
9
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:

Handige commando’s

1
2
3
4
5
6
7
8
# 手动封禁 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 [Optioneel] Meerdere servers beheren met SSH Config

Als je meerdere servers hebt, is het elke keer typen van ssh -p 22000 user@ip best vervelend. Je kunt dit flink versimpelen met SSH Config.

Configuratiebestand

Pas op je eigen lokale computer het bestand ~/.ssh/config aan:

1
vim ~/.ssh/config

Voeg de volgende configuratie toe:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 第一台服务器
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

Hoe te gebruiken

Nu kun je direct met de alias verbinden:

1
2
3
4
5
# 连接第一台服务器
ssh vps1

# 连接第二台服务器
ssh vps2

Geen gedoe meer met het onthouden van IP-adressen, poorten en gebruikersnamen!

3.9 [Optioneel] Alleen Cloudflare toestaan

Als je website volledig achter Cloudflare draait, kun je de poorten 80/443 zo instellen dat alleen Cloudflare IP’s erbij mogen. Dat maakt je setup direct een stuk veiliger.

⚠️ Let op: Voor deze configuratie moet je domein al aan het Cloudflare CDN gekoppeld zijn.

Automatisch configuratiescript

1
2
3
4
5
6
7
8
# 下载脚本
wget -O ~/.cloudflare-ufw.sh https://gist.githubusercontent.com/Xm798/12560579ce11f62027ea8da1fae37456/raw/b07ac8cfe09badf02fc70e2d8bc2da68cabbda50/cloudflare-ufw.sh

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

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

Dit script doet het volgende:

  1. Haal de nieuwste IP-reeksen op van de officiële Cloudflare-pagina
  2. Voeg UFW-regels toe zodat alleen deze IP’s poort 80/443 mogen benaderen
  3. Herlaad UFW

Automatische updates instellen

Cloudflare’s IP-reeksen kunnen in de loop der tijd veranderen. Zet daarom een wekelijkse automatische update op:

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

3.10 Tijdzone instellen

De standaardtijdzone is waarschijnlijk UTC. verander dit naar je eigen tijdzone, dat is een stuk makkelijker bij het lezen van logs:

1
2
3
4
5
6
7
8
# 查看当前时区
timedatectl

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

# 验证
date

设置时区

3.11 [Optioneel] Automatische beveiligingsupdates instellen

Laat je systeem zelf beveiligingspatches installeren, scheelt je weer een handmatige actie:

1
2
3
4
5
# 安装自动更新工具
sudo apt install -y unattended-upgrades

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

Kies “Yes” om automatische updates in te schakelen.

💡 Deze functie installeert automatisch beveiligingsupdates, maar zal je niet zomaar upgraden naar een gloednieuwe hoofdversie. Vrij veilig dus.

4. Samenvatting

Checklist voor de installatie

Nadat je alles hebt geconfigureerd, loop deze checklist even na om te controleren of je niks bent vergeten:

Controlepunt Commando Verwacht resultaat
Systeem is bijgewerkt apt update && apt list --upgradable Geen pakketten om te upgraden
Normale gebruiker kan sudoen sudo whoami Output root
Inloggen met key werkt ssh yourname@ip -p port Inloggen zonder wachtwoord
Wachtwoord-inloggen staat uit grep PasswordAuth /etc/ssh/sshd_config PasswordAuthentication no
SSH-poort is aangepast grep Port /etc/ssh/sshd_config Jouw ingestelde poort
Firewall staat aan ufw status Status: active
BBR is ingeschakeld sysctl net.ipv4.tcp_congestion_control = bbr
fail2ban draait systemctl status fail2ban active (running)
Tijdzone is ingesteld timedatectl Asia/Shanghai of jouw tijdzone
Lokale SSH-config cat ~/.ssh/config Server-alias is geconfigureerd

Locatie van belangrijke bestanden

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

Best practices voor veiligheid

  1. Update je systeem regelmatig: apt update && apt upgrade
  2. Check je inloglogs regelmatig: lastb (mislukte inlogpogingen), last (geslaagde inlogpogingen)
  3. Houd fail2ban-bans goed in de gaten
  4. Maak altijd even een backup voordat je belangrijke config-bestanden aanpast

5. Foutlogboek

Q1: Inloggen met key lukt niet en blijft om wachtwoord vragen?

Mogelijke oorzaken:

  1. Permissieprobleem (komt het vaakst voor)

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

  2. Public key niet correct gekopieerd

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

  3. SELinux bemoeit zich ermee (op CentOS/RHEL systemen)

    1
    restorecon -Rv ~/.ssh

Q2: Na het wijzigen van de poort kun je er niet meer in?

Stappen om het te checken:

  1. Controleer of de nieuwe poort in de firewall is geopend:

    1
    ufw status | grep 你的端口

  2. Controleer of de SSH-configuratie klopt:

    1
    grep Port /etc/ssh/sshd_config

  3. Controleer of de SSH-service draait:

    1
    systemctl status sshd

  4. Als je er helemaal niet meer in komt, log dan in via de VNC/console van je provider om het op te lossen.

Q2.5: Poort wijzigen werkt helemaal niet? (Lightweight cloud servers van providers)

Symptoom: Je hebt /etc/ssh/sshd_config aangepast, maar na het herstarten van de service luistert hij nog steeds op poort 22 en is de nieuwe poort niet actief.

Diagnostiek:

bash

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

Als de output er ongeveer zo uitziet:

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

Dan betekent dit dat poort 22 wordt beluisterd door init (PID 1), en niet door het sshd proces.

Waarom komt dat?: Bij sommige cloudproviders wordt de SSH voor hun “lichtgewicht applicatieservers” of “container instances” afgehandeld via een proxy in het platform. De sshd-instellingen op je server zelf doen dan niks.

De oplossing:

Type instance Hoe pas je de SSH-poort aan?
Traditionele ECS Pas sshd_config aan ✅
Lichtgewicht server Mogelijk via de cloudconsole, of wordt helemaal niet ondersteund
Container instance Vaak niet aanpasbaar

Kun je de poort op jouw instance niet aanpassen? Dan worden andere beveiligingsmaatregelen ineens een stuk belangrijker:

  • ✅ Maak een gewone gebruiker aan + zet root-login uit
  • ✅ Login via SSH-sleutels + zet wachtwoordlogin uit
  • ✅ Gebruik fail2ban tegen brute-force aanvallen

Zolang je dit maar goed regelt, blijf je behoorlijk veilig.

Q3: Heeft fail2ban mijzelf geblokkeerd?

1
2
3
4
5
# 用 VNC 登录后解封
fail2ban-client set sshd unbanip 你的IP

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

Q4: Kun je je site niet meer bereiken nadat UFW aan staat?

1
2
3
4
5
6
# 检查 80/443 是否开放
ufw status

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

Q5: Krijg je de melding “sudo niet gevonden” bij het uitvoeren van commando’s?

Bij een minimale Debian-installatie zit sudo er vaak niet bij. Installeer het dan even als root:

1
2
apt install sudo
usermod -aG sudo ittinker

6. One-click initialisatiescript (als je de smaak te pakken hebt)

Als je de bovenstaande stappen eenmaal goed onder de knie hebt, kun je dit script gebruiken om alles in één keer te initialiseren.

⚠️ Let op: Voordat je het script draait, zorg ervoor dat je je SSH-public key al klaar hebt staan.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
#!/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. Hoeveel veiliger is je server nu eigenlijk?

Stap Wat je gedaan hebt Waarom het belangrijk is
Systeem updaten Nieuwste patches geïnstalleerd Dicht bekende kwetsbaarheden
Nieuwe gebruiker aangemaakt Niet meer direct als root ingelogd Minder kans op per ongeluk foute acties
SSH-sleutels Sleutels in plaats van wachtwoorden Niet meer te kraken via brute force
Poort gewijzigd Weg van de standaardpoort 22 Minder kans om gescand te worden
Wachtwoorden uitgeschakeld Alleen inloggen met sleutels Wachtwoordaanvallen definitief onmogelijk
Root uitgeschakeld Root kan niet meer direct inloggen Moeilijker voor aanvallers
UFW-firewall Alleen noodzakelijke poorten open Kleine aanvalsoppervlakte
BBR-versnelling Netwerkprestaties geoptimaliseerd Snellere toegang
fail2ban Automatisch kwaadaardige IP’s bannen Stopt doorlopende aanvallen

Met deze stappen is je server al veiliger dan 90% van alle VPS’en.

Volgende post preview

In de volgende post duiken we in de SSH-sleutel inlogconfiguratie cheat sheet, waarin we de volgende punten gedetailleerd behandelen:

  • Sleutels genereren op verschillende besturingssystemen
  • Meerdere sleutels beheren
  • SSH Agent configureren
    | Veelvoorkomende SSH-client instellingen

Deze post is voor het laatst bijgewerkt: januari 2026

Onafhankelijke ontwikkelaars toolkit-serie, abonneer je om op de hoogte te blijven!