OpenClaw auf Hetzner (Docker, Production VPS Guide)

Ziel

Ein persistentes OpenClaw Gateway auf einem Hetzner VPS mit Docker betreiben – mit dauerhaftem State, vorinstallierten Binaries und sicherem Restart-Verhalten.

Wenn du “OpenClaw 24/7 für ~5 €” willst, ist das die einfachste zuverlässige Lösung. Die Hetzner-Preise ändern sich; nimm den kleinsten Debian/Ubuntu VPS und skaliere hoch, falls du auf OOMs stößt.

Was machen wir hier (einfach erklärt)?

• Einen kleinen Linux-Server mieten (Hetzner VPS)
• Docker installieren (isolierte App-Laufzeitumgebung)
• Das OpenClaw Gateway in Docker starten
• ~/.openclaw + ~/.openclaw/workspace auf dem Host persistieren (überlebt Restarts/Rebuilds)
• Auf die Control UI von deinem Laptop aus per SSH-Tunnel zugreifen

Zugriff auf das Gateway ist möglich über:

• SSH Port Forwarding von deinem Laptop
• Direkte Port-Freigabe, wenn du Firewall und Tokens selbst verwaltest

Diese Anleitung geht von Ubuntu oder Debian auf Hetzner aus. Bei einem anderen Linux VPS musst du die Pakete entsprechend anpassen. Für den generischen Docker-Ablauf siehe Docker.

Schnellübersicht (für erfahrene Admins)

1. Hetzner VPS bereitstellen
2. Docker installieren
3. OpenClaw Repository clonen
4. Persistente Host-Verzeichnisse anlegen
5. .env und docker-compose.yml konfigurieren
6. Benötigte Binaries ins Image einbacken
7. docker compose up -d
8. Persistenz und Gateway-Zugriff prüfen

Was du brauchst

• Hetzner VPS mit Root-Zugriff
• SSH-Zugriff von deinem Laptop
• Grundkenntnisse in SSH + Copy/Paste
• ~20 Minuten Zeit
• Docker und Docker Compose
• Model Auth Credentials
• Optional: Provider Credentials
  • WhatsApp QR
  • Telegram Bot Token
  • Gmail OAuth

1) VPS bereitstellen

Erstelle einen Ubuntu- oder Debian-VPS bei Hetzner.

Verbinde dich als Root:

ssh root@YOUR_VPS_IP

Diese Anleitung geht davon aus, dass der VPS stateful ist. Behandle ihn nicht als Wegwerf-Infrastruktur.

2) Docker installieren (auf dem VPS)

apt-get update
apt-get install -y git curl ca-certificates
curl -fsSL https://get.docker.com | sh

Prüfen:

docker --version
docker compose version

3) OpenClaw Repository clonen

git clone https://github.com/openclaw/openclaw.git
cd openclaw

Diese Anleitung geht davon aus, dass du ein Custom Image baust, um Binary-Persistenz zu garantieren.

4) Persistente Host-Verzeichnisse anlegen

Docker Container sind ephemer. Alle langlebigen Daten müssen auf dem Host liegen.

mkdir -p /root/.openclaw
mkdir -p /root/.openclaw/workspace

# Besitzer auf den Container-User setzen (uid 1000):
chown -R 1000:1000 /root/.openclaw
chown -R 1000:1000 /root/.openclaw/workspace

5) Umgebungsvariablen konfigurieren

Erstelle .env im Repository-Root.

OPENCLAW_IMAGE=openclaw:latest
OPENCLAW_GATEWAY_TOKEN=change-me-now
OPENCLAW_GATEWAY_BIND=lan
OPENCLAW_GATEWAY_PORT=18789

OPENCLAW_CONFIG_DIR=/root/.openclaw
OPENCLAW_WORKSPACE_DIR=/root/.openclaw/workspace

GOG_KEYRING_PASSWORD=change-me-now
XDG_CONFIG_HOME=/home/node/.openclaw

Starke Secrets generieren:

openssl rand -hex 32

Diese Datei nicht committen.

6) Docker Compose Konfiguration

Erstelle oder aktualisiere docker-compose.yml.

services:
  openclaw-gateway:
    image: ${OPENCLAW_IMAGE}
    build: .
    restart: unless-stopped
    env_file:
      - .env
    environment:
      - HOME=/home/node
      - NODE_ENV=production
      - TERM=xterm-256color
      - OPENCLAW_GATEWAY_BIND=${OPENCLAW_GATEWAY_BIND}
      - OPENCLAW_GATEWAY_PORT=${OPENCLAW_GATEWAY_PORT}
      - OPENCLAW_GATEWAY_TOKEN=${OPENCLAW_GATEWAY_TOKEN}
      - GOG_KEYRING_PASSWORD=${GOG_KEYRING_PASSWORD}
      - XDG_CONFIG_HOME=${XDG_CONFIG_HOME}
      - PATH=/home/linuxbrew/.linuxbrew/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
    volumes:
      - ${OPENCLAW_CONFIG_DIR}:/home/node/.openclaw
      - ${OPENCLAW_WORKSPACE_DIR}:/home/node/.openclaw/workspace
    ports:
      # Empfohlen: Gateway nur loopback-only auf dem VPS; Zugriff per SSH-Tunnel.
      # Für öffentliche Freigabe das `127.0.0.1:`-Präfix entfernen und Firewall entsprechend konfigurieren.
      - "127.0.0.1:${OPENCLAW_GATEWAY_PORT}:18789"

      # Optional: nur wenn du iOS/Android Nodes gegen diesen VPS laufen lässt und Canvas Host brauchst.
      # Bei öffentlicher Freigabe lies /gateway/security und konfiguriere die Firewall entsprechend.
      # - "18793:18793"
    command:
      [
        "node",
        "dist/index.js",
        "gateway",
        "--bind",
        "${OPENCLAW_GATEWAY_BIND}",
        "--port",
        "${OPENCLAW_GATEWAY_PORT}",
      ]

7) Benötigte Binaries ins Image einbacken (kritisch)

Binaries in einem laufenden Container zu installieren ist eine Falle. Alles, was zur Laufzeit installiert wird, geht beim Restart verloren.

Alle externen Binaries, die von Skills benötigt werden, müssen zur Build-Zeit des Images installiert werden.

Die Beispiele unten zeigen nur drei gängige Binaries:

• gog für Gmail-Zugriff
• goplaces für Google Places
• wacli für WhatsApp

Das sind Beispiele, keine vollständige Liste. Du kannst beliebig viele Binaries nach dem gleichen Muster installieren.

Wenn du später neue Skills hinzufügst, die zusätzliche Binaries brauchen, musst du:

1. Das Dockerfile aktualisieren
2. Das Image neu bauen
3. Die Container neu starten

Beispiel Dockerfile

FROM node:22-bookworm

RUN apt-get update && apt-get install -y socat && rm -rf /var/lib/apt/lists/*

# Beispiel Binary 1: Gmail CLI
RUN curl -L https://github.com/steipete/gog/releases/latest/download/gog_Linux_x86_64.tar.gz \
  | tar -xz -C /usr/local/bin && chmod +x /usr/local/bin/gog

# Beispiel Binary 2: Google Places CLI
RUN curl -L https://github.com/steipete/goplaces/releases/latest/download/goplaces_Linux_x86_64.tar.gz \
  | tar -xz -C /usr/local/bin && chmod +x /usr/local/bin/goplaces

# Beispiel Binary 3: WhatsApp CLI
RUN curl -L https://github.com/steipete/wacli/releases/latest/download/wacli_Linux_x86_64.tar.gz \
  | tar -xz -C /usr/local/bin && chmod +x /usr/local/bin/wacli

# Weitere Binaries nach dem gleichen Muster hinzufügen

WORKDIR /app
COPY package.json pnpm-lock.yaml pnpm-workspace.yaml .npmrc ./
COPY ui/package.json ./ui/package.json
COPY scripts ./scripts

RUN corepack enable
RUN pnpm install --frozen-lockfile

COPY . .
RUN pnpm build
RUN pnpm ui:install
RUN pnpm ui:build

ENV NODE_ENV=production

CMD ["node","dist/index.js"]

8) Bauen und starten

docker compose build
docker compose up -d openclaw-gateway

Binaries prüfen:

docker compose exec openclaw-gateway which gog
docker compose exec openclaw-gateway which goplaces
docker compose exec openclaw-gateway which wacli

Erwartete Ausgabe:

/usr/local/bin/gog
/usr/local/bin/goplaces
/usr/local/bin/wacli

9) Gateway prüfen

docker compose logs -f openclaw-gateway

Erfolg:

[gateway] listening on ws://0.0.0.0:18789

Von deinem Laptop aus:

ssh -N -L 18789:127.0.0.1:18789 root@YOUR_VPS_IP

Öffne:

http://127.0.0.1:18789/

Füge dein Gateway Token ein.

Was wird wo persistiert (Source of Truth)

OpenClaw läuft in Docker, aber Docker ist nicht die Source of Truth. Alle langlebigen Daten müssen Restarts, Rebuilds und Reboots überleben.