OpenClaw auf einem günstigen VPS betreiben — kein Mac Mini nötig
Der Irrtum über Hardware-Anforderungen
Diese Woche verbreitet sich auf X ein Beitrag: "Build a Free OpenClaw Setup in 8 Minutes (No Mac Mini)". Die Reaktionen zeigen, dass viele dachten, ein Mac Mini sei Voraussetzung.
Das ist ein Missverständnis, das uns auch begegnet ist.
KI-Agenten brauchen keine teure Hardware — sie brauchen eine zuverlässige Internetverbindung und einen stabilen Prozess, der läuft. Das kann ein Mini-PC sein. Es kann aber auch ein VPS für 4 Euro im Monat sein. Bei uns ist es Letzteres.
Dieser Post zeigt Schritt für Schritt, wie wir unser 6-Agenten-Setup auf einem günstigen Hetzner-Server aufgebaut haben — für unter 10 Euro im Monat, 24/7 verfügbar, ohne lokale Hardware.
---
Warum VPS statt lokaler Hardware?
Es gibt legitime Gründe für beides. Hier sind unsere Überlegungen:
Vorteile eines VPS:
Vorteile lokaler Hardware:
Für unser Setup haben wir uns für den VPS entschieden, weil wir Cloud-APIs (Anthropic) nutzen und keine lokalen Modelle brauchen. Falls ihr lokale LLMs mit Ollama betreiben wollt, empfehlen wir eher einen Mini-PC mit ausreichend RAM.
---
Schritt 1: Server bei Hetzner erstellen
Hetzner ist unter Entwicklern verbreitet — fair priced, europäische Rechenzentren, solide SLAs.
Empfohlene Konfiguration für ein einzelnes Agenten-Setup:
Nach der Erstellung erhältst du eine IP-Adresse. Erster Login:
```bash
ssh root@<DEINE-IP>
```
---
Schritt 2: Grundsicherung und Updates
Direkt nach dem ersten Login — bevor sonst irgendetwas passiert:
```bash
# System aktualisieren
apt update && apt upgrade -y
# Firewall einrichten (ufw)
apt install ufw -y
ufw default deny incoming
ufw default allow outgoing
ufw allow ssh # Port 22 — SSH behalten!
ufw enable
# Prüfen
ufw status
```
Was wir NICHT freigeben: HTTP (80), HTTPS (443), oder irgendwelche Agent-Ports. Unsere Agenten sind nur über Tailscale erreichbar — kein einziger Port für den normalen Internetzugriff.
Falls du Tailscale noch nicht kennst: Es ist ein verschlüsseltes Mesh-Netzwerk (WireGuard-basiert), das Geräte so verbindet, als wären sie im selben lokalen Netzwerk — ohne offene Ports. Gratis für Privatnutzer und kleine Teams.
---
Schritt 3: Tailscale installieren
```bash
# Tailscale installieren
curl -fsSL https://tailscale.com/install.sh | sh
# Starten und einloggen
tailscale up
# Den angezeigten Link im Browser öffnen und mit deinem Tailscale-Account verbinden
```
Nach dem Login erscheint der Server in deinem Tailscale-Dashboard. Ab jetzt kannst du ihn über seinen Tailscale-Hostnamen erreichen (z.B. `my-hetzner-server`) — von jedem Gerät, das ebenfalls in deinem Tailscale-Netzwerk ist.
Wichtig: Jetzt kannst du auch den SSH-Port in der UFW-Firewall wieder schließen und nur über Tailscale verbinden. Noch sicherer, aber optional.
---
Schritt 4: Docker installieren
```bash
# Docker installieren (offizieller Weg)
curl -fsSL https://get.docker.com | sh
# Docker ohne sudo nutzbar machen
usermod -aG docker $USER
# Neu einloggen damit die Gruppe greift
exit
ssh root@<DEINE-IP>
# Test
docker run hello-world
```
Wenn "Hello from Docker!" erscheint: Docker läuft.
---
Schritt 5: OpenClaw installieren
```bash
# Node.js 22 installieren (OpenClaw-Anforderung)
curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
apt install nodejs -y
# Version prüfen
node --version # Sollte v22.x.x sein
# OpenClaw installieren
npm install -g openclaw@latest
# Version prüfen
openclaw version
```
---
Schritt 6: Ersten Agenten einrichten
```bash
# Onboarding-Wizard starten
openclaw onboard
# Der Wizard führt durch:
# 1. LLM-Provider wählen (z.B. Anthropic)
# 2. API-Key eingeben
# 3. Modell wählen (z.B. claude-sonnet-4-5)
# 4. Kanal einrichten (z.B. Telegram)
# 5. Workspace-Ordner festlegen
```
Tipp für den API-Key: Nicht direkt eingeben, wenn das Terminal geloggt wird. Besser:
```bash
# .env-Datei anlegen
mkdir -p ~/.openclaw/workspace
cat > ~/.openclaw/workspace/.env << 'EOF'
ANTHROPIC_API_KEY=sk-ant-...
TELEGRAM_TOKEN=123456:ABC...
EOF
chmod 600 ~/.openclaw/workspace/.env
```
---
Schritt 7: Gateway als systemd-Service einrichten
Das ist der Unterschied zwischen "läuft wenn ich eingeloggt bin" und "läuft immer, auch nach einem Neustart".
```bash
# systemd-Service erstellen
cat > /etc/systemd/system/openclaw.service << 'EOF'
[Unit]
Description=OpenClaw Gateway
After=network.target
[Service]
Type=simple
User=root
WorkingDirectory=/root/.openclaw/workspace
EnvironmentFile=/root/.openclaw/workspace/.env
ExecStart=/usr/local/bin/openclaw gateway start --foreground
Restart=always
RestartSec=10
[Install]
WantedBy=multi-user.target
EOF
# Service aktivieren und starten
systemctl daemon-reload
systemctl enable openclaw
systemctl start openclaw
# Status prüfen
systemctl status openclaw
```
Ab jetzt startet das Gateway automatisch bei jedem Server-Neustart.
```bash
# Logs anschauen
journalctl -u openclaw -f
```
---
Schritt 8: Multi-Agenten mit Docker Compose
Für mehrere Agenten nutzen wir Docker Compose. Jeder Agent bekommt seinen eigenen Container und Workspace.
Dateistruktur:
```
/opt/agents/
├── docker-compose.yml
├── workspaces/
│ ├── sam/
│ │ ├── SOUL.md
│ │ ├── MEMORY.md
│ │ └── .env
│ ├── peter/
│ └── maya/
```
```yaml
# /opt/agents/docker-compose.yml
version: "3.8"
services:
agent-sam:
image: openclaw/openclaw:latest
container_name: agent-sam
restart: always
environment:
- OPENCLAW_WORKSPACE=/workspace
env_file:
- ./workspaces/sam/.env
volumes:
- ./workspaces/sam:/workspace:rw
networks:
- agents
agent-peter:
image: openclaw/openclaw:latest
container_name: agent-peter
restart: always
env_file:
- ./workspaces/peter/.env
volumes:
- ./workspaces/peter:/workspace:rw
networks:
- agents
agent-maya:
image: openclaw/openclaw:latest
container_name: agent-maya
restart: always
env_file:
- ./workspaces/maya/.env
volumes:
- ./workspaces/maya:/workspace:rw
networks:
- agents
networks:
agents:
driver: bridge
```
```bash
# Alle Agenten starten
cd /opt/agents
docker compose up -d
# Status prüfen
docker compose ps
# Logs eines Agenten
docker compose logs -f agent-sam
```
---
Ressourcen-Verbrauch in der Praxis
Auf unserem CX32 (4 vCPU, 8 GB RAM) mit 6 Agenten:
| Ressource | Verbrauch |
|-----------|-----------|
| RAM gesamt | ~2.4 GB (idle) |
| CPU idle | <5% |
| CPU unter Last | 20–40% kurzzeitig |
| Netzwerk | <1 GB/Monat |
| Disk | ~8 GB (Logs + Workspaces) |
Der Großteil der Rechenarbeit passiert beim LLM-Provider, nicht auf dem Server. Unser Server ist hauptsächlich für Koordination, Kanal-Kommunikation und Datei-Operationen zuständig — das ist leichtgewichtig.
Fazit: Ein CX22 für 4 Euro/Monat reicht für 1–3 Agenten locker. Für 6 Agenten nehmt den CX32 für 9 Euro.
---
Monitoring: Wissen was läuft
Auf einem Remote-Server ist Monitoring wichtiger als lokal. Zwei einfache Maßnahmen:
```bash
# Uptime-Check via cron (stündlich eigene IP pingen)
# Oder: kostenloser externer Service wie UptimeRobot (uptimerobot.com)
# überwacht per HTTP-Ping ob euer Server antwortet
# Disk-Warnungen
# Cron-Job der Disk-Nutzung prüft und bei >80% eine Telegram-Nachricht sendet
# (Sam macht das automatisch als Teil seines Heartbeat-Checkups)
```
Sam als sein eigener Monitor: Einer unserer Cron-Jobs lässt Sam einmal täglich den eigenen Server-Status prüfen und Auffälligkeiten melden. KI-Agenten als eigene Monitoring-Lösung — das schließt den Kreis.
---
Das Ergebnis
Ein produktives 6-Agenten-Setup für unter 10 Euro im Monat:
Das ist kein Hobby-Setup. Das ist produktionsreif — und günstiger als ein Spotify-Abo.
Das vollständige Playbook dokumentiert die genaue Docker-Konfiguration, die Workspace-Struktur, Tailscale-Integration und System-Prompts für jeden der 6 Agenten.
Komplett auf Deutsch verfügbar. 🇩🇪