Deine erste Stunde mit dem VPS: Komplette Einrichtung von nacktem Server bis sicher nutzbar (mach dein OpenClaw sicherer)

Ein frisch gekaufter VPS ist wie eine unverschlossene Tür, an die weltweit Script-Kids klopfen. Dieser Artikel zeigt dir, wie du die Tür sicher verriegelst. Damit dein „openclaw“ nicht unkontrolliert herumstromert.

0. Vorab

Du hast dir gerade einen VPS gekauft, hast voller Vorfreude die IP und das root-Passwort in der Hand – und jetzt?

Die meisten machen dann einfach das: Direkt Software installieren und das Projekt deployen.

Das ist ein gefährlicher Reflex.

Dein VPS hat eine öffentliche IP-Adresse. Das bedeutet, dass jeder Mensch auf der ganzen Welt versuchen kann, sich dorthin zu verbinden. Und in der Standardkonfiguration gilt:

• Der Port 22 ist öffentlich zugänglich
• Der Benutzername ist das allseits bekannte root
• Ein einziges Passwort schützt dich noch

Jeden Tag scannen unzählige automatisierte Skripte ganze IP-Blöcke und versuchen mit gängigen Passwörtern, per Brute-Force einzudringen. Dein Server wird ab der ersten Sekunde nach dem Hochfahren bereits angegriffen.

Deshalb lautet die goldene Regel: Das Allererste nach dem VPS-Kauf ist nicht die Software-Installation, sondern die Sicherheits-Grundeinrichtung.

---

1. Unser Ziel

Das Ziel dieses Artikels ist:

• ✅ Sicheren Remote-Zugang einrichten: SSH-Login mit Keys + abweichender Port
• ✅ Einen normalen User anlegen: Nicht direkt als root arbeiten
• ✅ Firewall konfigurieren: Nur wirklich nötige Ports aufmachen
• ✅ Netzwerk-Boost aktivieren: Mit BBR richtig Gas geben
• ✅ Brute-Force-Angriffen vorbeugen: fail2ban bannt böswillige IPs automatisch

Wenn du das alles durch hast, steht dein VPS auf einem soliden Fundament und du kannst da beruhigt deine Dienste deployen.

---

2. Planung & Gedanken

Warum diese Konfiguration?

Ein frisch gekaufter VPS ist wie eine nagelneue Wohnung im Rohbau:

Standardzustand	Risiko	Unsere Lösung
Direkter Login als root	Zu hohe Rechte, fatal bei Fehlern	Normaler User + sudo
Login per Passwort	Anfällig für Brute-Force-Angriffe	SSH-Key-Login
Standard-Port 22	Liegt im Fokus von Scannern	Nicht-Standard-Port
Firewall aus	Alle Ports nach außen offen	UFW: Nur nötige Ports durchlassen
Natives Netzwerk	Hoher Paketverlust, hohe Latenz	BBR Congestion Control

Der grobe Ablauf

Wir gehen genau in dieser Reihenfolge vor, und ich erkläre dir bei jedem Schritt, warum wir das eigentlich machen.

3. Los geht’s: Schritt-für-Schritt

3.1 Erster Login und System-Update

Server-IP besorgen

Sobald du deinen VPS gekauft hast, schickt dir der Anbieter:

• IP-Adresse: z. B. 192.168.1.100
• Port: Meistens 22 (manche Provider nutzen abweichende Ports)
• Benutzername: In der Regel root
• Passwort: Ein zufällig generierter String

SSH-Verbindung

Mac / Linux-User: Öffne das Terminal und tippe einfach Folgendes ein:

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

Windows-User:

• Windows 10/11 bringt OpenSSH direkt mit, du kannst den Befehl oben also einfach in PowerShell oder CMD nutzen
• Oder du greifst auf Tools wie Termius oder MobaXterm zurück

Beim ersten Verbinden poppt die Abfrage zum Bestätigen des Fingerprints auf:

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

Das System fragt dich im Prinzip: „Ich kenne diesen Rechner nicht – willst du dich wirklich verbinden?“

Tippe yes ein und drück Enter. Danach kommt das Passwort (Achtung: Bei der Eingabe wird nichts angezeigt, das ist normale Sicherheitsarchitektur), dann wieder Enter.

Wenn du einen Prompt in dieser Art siehst, hast du dich erfolgreich eingeloggt:

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

💡 Wozu eigentlich den Fingerprint checken?

Das schützt dich vor sogenannten Man-in-the-Middle-Angriffen. Beim allerersten Login speicherst du den Fingerprint des Servers ab. Wenn der bei einer späteren Verbindung plötzlich anders aussieht, ist das ein Warnsignal – vielleicht versucht da jemand, sich als dein Server auszugeben.

Lern deinen Server kennen

Nach dem Login schauen wir uns erst mal an, auf welchem Gerät du da eigentlich gelandet bist:

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

# 查看内核版本
uname -r

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

# 查看内存
free -h

# 查看磁盘
df -h

Merke dir diese Infos, das wird dir später bei der Fehlersuche extrem helfen.

System-Update

Jetzt, wo du weißt, wo du stehst, ist die erste echte Aufgabe: Bring das System auf den neuesten Stand. Das Image auf einem frischen Server ist oft schon ein paar Monate alt, und da zwischendurch bestimmt ein paar Sicherheits-Patches veröffentlicht wurden:

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

Was die Parameter bedeuten:

• apt update: Aktualisiert den Paket-Index
• apt full-upgrade: Zieht alle Updates für die Software – inklusive des Kernels
• -y: Bestätigt automatisch, du musst also nicht ständig “yes” eintippen
• apt autoremove: Räumt nicht mehr benötigte Abhängigkeiten auf
• apt autoclean: Leert den Cache der heruntergeladenen Installationspakete

⏱️ Dieser Schritt kann ein paar Minuten dauern, je nachdem, wie viele Updates anstehen. Wenn zwischendurch mal eine Bestätigung verlangt wird, einfach bestätigen und mitlaufen lassen.

Checken, ob ein Reboot nötig ist

Nach einem Kernel-Update musst du den Server meistens einmal neu starten, damit alles greift:

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

Wenn da steht, dass ein Neustart fällig ist:

reboot

Nach dem Reboot loggst du dich einfach per SSH wieder ein.

Nützliche Tools installieren

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

Wofür du diese Tools brauchst:

Tool	Zweck
sudo	Normale Nutzer lassen Admin-Befehle ausführen
curl / wget	Dateien herunterladen
git	Versionskontrolle
vim	Texteditor
htop	Schickere Prozessüberwachung
tree	Verzeichnisstruktur als Baum anzeigen
net-tools	Netzwerk-Tools (ifconfig, netstat etc.)
ufw	Simple und handliche Firewall
fail2ban	Schutz gegen Brute-Force-Angriffe
neofetch	Systeminfos schön aufbereitet

3.2 Einen Nicht-root-Benutzer anlegen

Warum nicht direkt root nutzen?

Der root-User hat einfach viel zu viele Rechte – ein kleiner Tippfehler rm -rf / und alles ist weg. Für den Alltag nimmst du besser einen normalen User. Wenn du mal Admin-Rechte brauchst, holst du dir die einfach mit sudo.

Der Lobster (openclaw) ist ein echtes Monster – dem würdest du doch auch nicht einfach root geben, oder?

Benutzer anlegen

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

Das System fragt dich jetzt nach einem Passwort und ein paar weiteren Infos:

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

sudo-Rechte vergeben

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

Kurz testen:

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

# 测试 sudo 是否生效
sudo whoami

Wenn root als Ausgabe erscheint, hast du sudo erfolgreich eingerichtet.

💡 Pro-Tipp

Mit exit springst du direkt zurück zum root-User. Für die nächsten Schritte bleiben wir erstmal im root-Kontext und richten alles ein. Danach wechseln wir wieder zum normalen User.

---

3.3 SSH-Key-Login einrichten

Key-Authentifizierung vs. Passwort-Authentifizierung

Key-Login ist deutlich sicherer als ein Passwort:

• Passwörter lassen sich bruteforcen, Keys quasi gar nicht
• Du musst nicht jedes Mal ein Passwort tippen – viel bequemer
• Selbst wenn dein Passwort geleakt wird, kommt ohne den privaten Key trotzdem niemand rein

Schritt 1: Schlüsselpaar lokal generieren

Führe das auf deinem Rechner aus (nicht auf dem Server):

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

Dann erscheint folgende Abfrage:

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

Einfach mit Enter bestätigen, um den Standardpfad zu übernehmen. Wir verwenden hier ./ittinker – das bedeutet, die Datei wird im aktuellen Verzeichnis unter dem Namen ittinker gespeichert.

Enter passphrase (empty for no passphrase):

Du kannst noch ein Passwort für den Key vergeben (für eine extra Sicherheitsschicht) oder einfach leer lassen und Enter drücken.

Wenn der Schlüssel generiert ist, findest du im Verzeichnis ~/.ssh/ zwei Dateien (hier mit den Standardnamen, sofern du vorher einfach Enter gedrückt hast):

• id_ed25519: Der private Schlüssel – den darfst du auf keinen Fall weitergeben!
• id_ed25519.pub: Der öffentliche Schlüssel – der muss auf den Server hochgeladen werden

💡 ed25519 vs. RSA

ed25519 ist der aktuell empfohlene Algorithmus – sicherer und mit kürzeren Keys als das klassische RSA. Falls dein System zu alt ist und ihn nicht unterstützt, kannst du ssh-keygen -t rsa -b 4096 nutzen.

Ein kleiner Nebenaspekt: Ein ed25519-Key ist recht klein, während RSA-Dateien ziemlich groß werden. Hab mal eine KI gefragt – die Größe spielt keine Rolle, das liegt einfach an der Art des Algorithmus.

Schritt 2: Den öffentlichen Schlüssel auf den Server laden

Variante A: Mit ssh-copy-id (empfohlen)

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

Nachdem du dein Passwort eingegeben hast, wird der öffentliche Schlüssel automatisch auf den Server kopiert.

Variante B: Manuell kopieren

Falls ssh-copy-id nicht klappt, kannst du das auch manuell machen:

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

Kopiere die Ausgabe (ein langer Text, der mit ssh-ed25519 beginnt).

# 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

⚠️ Berechtigungen sind extrem wichtig!

SSH ist da sehr streng mit den Dateirechten:

• .ssh Verzeichnis: 700 (nur du selbst hast Zugriff)
• authorized_keys Datei: 600 (nur du selbst kannst lesen und schreiben)

Wenn die Rechte nicht stimmen, verweigert SSH den Login mit dem Key.

Schritt 3: Key-Login testen

Öffne ein neues Terminal-Fenster (lass das alte offen, falls du was vermasselst hast du noch ein Backup), und test den Key-Login:

ssh ittinker@你的服务器IP

Wenn du dich jetzt ohne Passwort einloggen kannst, hast du es geschafft! 🎉

(Falls du für deinen Private Key eine Passphrase vergeben hast, wird er nach dem Key-Passwort fragen – das ist völlig normal)

Wir haben hier den Parameter -i drangehängt, weil dieser Key nicht im Standard-Pfad liegt, sondern im aktuellen Verzeichnis. Wenn wir das nicht angeben, nimmt das System einfach den Default-Key.

---

3.4 SSH absichern

Jetzt, wo der Key-Login läuft, bringen wir SSH auf Vordermann:

1. Den Standard-Port ändern (schützt vor automatischen Scans)
2. Passwort-Login deaktivieren
3. Direkten Root-Login verbieten

SSH-Konfigurationsdatei bearbeiten

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

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

Suche die folgenden Einstellungen und passe sie an (einige davon sind vielleicht auskommentiert – entferne einfach das # davor):

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

# 禁止 root 登录
PermitRootLogin no

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

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

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

# 最大认证尝试次数
MaxAuthTries 3

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

Speichern und beenden (ctrl + o).

Bei Nano speicherst du mit Strg + O. Er fragt dann nach dem Dateinamen – einfach Enter drücken. Zum Beenden drückst du Strg + X.

SSH-Dienst neu starten

systemctl restart sshd.service

⚠️ Wichtiger Hinweis!

Schließ nicht sofort dein aktuelles Terminal! Teste zuerst in einem neuen Fenster, ob du dich mit der neuen Konfiguration problemlos einloggen kannst:

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

Wenn das klappt, kannst du das alte Fenster schließen. Wenn du dich nicht einloggen kannst, kannst du die Konfiguration im noch offenen alten Fenster ganz entspannt reparieren.

Wenn du einen Lightweight-Server gemietet hast, lässt sich dieser Port meistens nicht ändern. Bei klassischen ECS-Instanzen klappt das hingegen problemlos – pass also gut auf, was du da hast.

---

3.5 UFW-Firewall einrichten

UFW (Uncomplicated Firewall) ist das Standard-Firewall-Tool von Ubuntu. Super einfach zu konfigurieren, aber trotzdem richtig mächtig.

Grundkonfiguration

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

ufw enable

Dann kommt diese Abfrage:

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

Tippe y ein, um zu bestätigen.

Status prüfen

ufw status verbose

23022 war ein Tippfehler von mir – passt das einfach an eure eigenen Gegebenheiten an

Die Ausgabe sieht dann ungefähr so aus:

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)

Befehle zum schnellen Nachschlagen

# 查看状态
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-Beschleunigung aktivieren

BBR (Bottleneck Bandwidth and Round-trip propagation time) ist ein von Google entwickelter TCP-Staukontroll-Algorithmus, der die Netzwerkleistung spürbar verbessern kann.

Mit einem Klick aktivieren

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

# 使配置生效
sysctl -p

Prüfen, ob es aktiv ist

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

Die Ausgabe sollte so aussehen:

net.ipv4.tcp_congestion_control = bbr

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

Ausgabe ungefähr so:

tcp_bbr    20480  3

💡 Die Wirkung von BBR

Nach der Aktivierung von BBR wirst du besonders bei instabilen Verbindungen oder hoher Latenz deutlich merken:

• Downloads sind schneller
• SSH-Sitzungen laufen flüssiger
• Seiten laden schneller

---

3.7 fail2ban einrichten gegen Brute-Force-Angriffe

fail2ban überwacht deine Logs und bannt IPs automatisch, die zu oft erfolglos versucht haben, sich anzumelden.

Grundkonfiguration

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

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

Such den Bereich [sshd] und stell sicher, dass folgende Einstellungen drinstehen:

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

Dienst starten

# 重启 fail2ban
systemctl restart fail2ban

# 设置开机自启
systemctl enable fail2ban

Status prüfen

# 查看 fail2ban 状态
fail2ban-client status

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

Die Ausgabe sieht ungefähr so aus:

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:

Häufige Befehle

# 手动封禁 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 [Optional] Mehrere Server mit SSH Config verwalten

Wenn du mehrere Server hast, ist es super nervig, jedes Mal ssh -p 22000 user@ip einzutippen. Mit SSH Config kannst du dir das Leben leichter machen.

Konfigurationsdatei

Bearbeite ~/.ssh/config auf deinem lokalen Rechner:

vim ~/.ssh/config

Füge folgende Konfiguration hinzu:

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

Verwendung

Jetzt kannst du dich direkt über den Alias verbinden:

# 连接第一台服务器
ssh vps1

# 连接第二台服务器
ssh vps2

Kein IP-, Port- oder Benutzernamen-Merkschema mehr nötig!

---

3.9 [Optional] Zugriff nur über Cloudflare erlauben

Wenn deine Website komplett hinter Cloudflare läuft, kannst du die Ports 80/443 so einstellen, dass nur noch Cloudflare-IPs Zugriff haben. Das bringt extra Sicherheit.

⚠️ Achtung: Für diese Konfiguration muss deine Domain bereits im Cloudflare CDN eingebunden sein.

Automatisches Konfigurationsskript

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

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

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

Dieses Skript macht Folgendes:

1. Hol dir die aktuellsten IP-Subnetze direkt von Cloudflare
2. Füge UFW-Regeln hinzu, damit nur noch diese IPs auf Port 80/443 zugreifen dürfen
3. Lade UFW neu

Geplantes Update einrichten

Die IP-Subnetze von Cloudflare können sich mal ändern. Richten wir also ein wöchentliches Auto-Update ein:

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

---

3.10 Zeitzone einstellen

Standardmäßig ist wahrscheinlich UTC eingestellt. Stell das auf deine eigene Zeitzone um, dann lassen sich Logs viel leichter lesen:

# 查看当前时区
timedatectl

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

# 验证
date

---

3.11 [Optional] Automatische Sicherheitsupdates einrichten

Lass das System Sicherheits-Patches automatisch installieren, dann musst du nicht jedes Mal per Hand ran:

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

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

Wähl hier „Yes", um die automatischen Updates zu aktivieren.

💡 Die Funktion installiert automatisch Sicherheitsupdates, führt aber kein Upgrade auf eine ganz neue Major-Version durch. Ist also relativ sicher.

---

4. Zusammenfassung

Checkliste für die Initialisierung

Wenn du mit der ganzen Konfiguration durch bist, geh diese Checkliste nochmal durch:

Checkpunkt	Befehl	Erwartetes Ergebnis
System ist aktuell	apt update && apt list --upgradable	Keine aktualisierbaren Pakete
Normaler User kann sudo	sudo whoami	Ausgabe von root
Key-Login funktioniert	ssh yourname@ip -p port	Login ohne Passwort
Passwort-Login deaktiviert	grep PasswordAuth /etc/ssh/sshd_config	PasswordAuthentication no
SSH-Port geändert	grep Port /etc/ssh/sshd_config	Dein selbst festgelegter Port
Firewall aktiv	ufw status	Status: active
BBR aktiviert	sysctl net.ipv4.tcp_congestion_control	= bbr
fail2ban läuft	systemctl status fail2ban	active (running)
Zeitzone gesetzt	timedatectl	Asia/Shanghai oder deine Zeitzone
Lokale SSH-Config	cat ~/.ssh/config	Server-Alias eingerichtet

Wichtige Dateipfade

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

Security Best Practices

1. System regelmäßig updaten: apt update && apt upgrade
2. Login-Logs regelmäßig checken: lastb (fehlgeschlagene Logins), last (erfolgreiche Logins)
3. fail2ban-Bans im Blick behalten
4. Vor Änderungen an wichtigen Config-Dateien immer ein Backup machen

---

5. Troubleshooting-Log

Q1: Key-Login schlägt fehl und er will trotzdem ein Passwort?

Mögliche Ursachen:

1. Berechtigungsproblem (häufigster Fall)

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

2. Public Key wurde nicht richtig kopiert

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

3. SELinux macht Ärger (bei CentOS/RHEL)

   restorecon -Rv ~/.ssh

Q2: Nach dem Port-Wechsel keine Verbindung mehr?

Fehlersuche Schritt für Schritt:

1. Stell sicher, dass der neue Port in der Firewall freigegeben ist:

   ufw status | grep 你的端口

2. Prüf, ob die SSH-Konfiguration stimmt:

   grep Port /etc/ssh/sshd_config

3. Geh sicher, dass der SSH-Dienst läuft:

   systemctl status sshd

4. Wenn gar nichts mehr geht, logg dich über die VNC-Konsole deines Anbieters ein und reparier es.

Q2.5: Der Port-Wechsel zieht gar nicht erst? (Cloud-Anbieter Lite-Server)

Symptom: Du hast /etc/ssh/sshd_config geändert, aber nach dem Neustart des Dienstes lauscht er immer noch auf Port 22 und der neue Port will nicht.

Diagnose:

bash

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

Wenn die Ausgabe in etwa so aussieht:

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

dann lauscht auf Port 22 init (PID 1) und nicht etwa der sshd-Prozess.

Warum? Bei einigen Cloud-Anbietern wird der SSH-Zugang bei „Lightweight Servern“ oder „Container-Instanzen über die Plattform-Ebene proxied. Deine interne sshd-Konfiguration auf dem Server wird dann komplett ignoriert.

Die Lösung:

Instanztyp	SSH-Port ändern
Klassische ECS	sshd_config anpassen ✅
Lightweight Server	Eventuell nur über das Cloud-Dashboard änderbar oder gar nicht unterstützt
Container-Instanzen	Änderung in der Regel nicht unterstützt

Wenn deine Instanz den Port-Wechsel nicht unterstützt, sind andere Sicherheitsmaßnahmen umso wichtiger:

• ✅ Einen normalen User anlegen + root-Login deaktivieren
• ✅ Login per SSH-Key + Passwort-Login deaktivieren
• ✅ fail2ban gegen Brute-Force-Angriffe

Wenn du diese Punkte sauber umsetzt, ist dein System trotzdem richtig gut abgesichert.

Q3: fail2ban hat mich selbst ausgesperrt?

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

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

Q4: Nach dem Aktivieren von UFW ist die Website nicht mehr erreichbar?

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

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

Q5: Beim Ausführen von Befehlen kommt „sudo nicht gefunden“?

Bei einer minimalen Debian-Installation fehlt sudo oft. Installiere es einfach als root:

apt install sudo
usermod -aG sudo ittinker

---

6. Ein-Klick-Init-Skript (für Fortgeschrittene)

Wenn du die obigen Schritte schon draufhast, kannst du mit diesem Skript dein Setup im Handumdrehen initialisieren.

⚠️ Achtung: Bevor du das Skript losjagst, stell sicher, dass dein SSH-Public-Key schon fertig ist.

#!/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. Wie viel sicherer ist dein Server jetzt eigentlich?

Schritt	Was du gemacht hast	Warum es wichtig ist
System geupdatet	Neueste Patches installiert	Bekannte Lücken gestopft
Neuen User angelegt	Nicht mehr direkt als root eingeloggt	Weniger Risiko für Versehen
SSH-Key	Schlüssel statt Passwort	Kein Brute-Force mehr möglich
Port geändert	Weg vom Standard-Port 22	Geringere Chance, beim Scannen gefunden zu werden
Passwort-Login deaktiviert	Login nur noch mit Key	Passwort-Angriffe komplett ausgeschlossen
root-Login deaktiviert	root kann sich nicht mehr direkt einloggen	Erschwert Angreifern das Leben
UFW-Firewall	Nur nötige Ports offen	Angriffsfläche minimiert
BBR-Turbo	Netzwerk-Performance optimiert	Mehr Speed beim Zugriff
fail2ban	Böse IPs automatisch gebannt	Stoppt hartnäckige Angriffe

Mit diesen Schritten ziehst du an 90 % aller VPS auf dem Markt vorbei, was die Sicherheit angeht.

---

Was im nächsten Teil kommt

Im nächsten Teil stürzen wir uns auf den SSH-Key-Login Setup-Cheatcode und gehen richtig ins Detail:

• Wie du auf verschiedenen Systemen Keys generierst
• Mehrere Keys verwalten
• SSH Agent einrichten
• Die üblichen Einstellungen in gängigen SSH-Clients

---

Dieser Artikel wurde zuletzt aktualisiert: Januar 2026

Toolbox-Serie für Indie-Entwickler, abonniere gerne für mehr!