OpenClaw auf Hetzner: Dein Production-Setup mit Docker

Kennst du das? Dein lokales Setup läuft super, aber sobald du deinen Laptop zuklappst, ist der Agent offline. Wenn du versuchst, das Ganze auf einen Server zu schieben, merkst du schnell: Ohne die richtige Struktur sind nach jedem Neustart oder Image-Update deine installierten Tools und Konfigurationen weg.

Du willst, dass dein OpenClaw Gateway 24/7 erreichbar ist, ohne dass du dich ständig um manuelle Installationen kümmern musst. Ein kleiner VPS für ein paar Euro reicht völlig aus, wenn du Docker clever nutzt und den State richtig auslagerst.

Voraussetzungen

• Hetzner VPS mit root-Zugriff
• SSH-Zugriff von deinem Rechner aus
• Grundkenntnisse in SSH und Copy/Paste
• Etwa 20 Minuten Zeit
• Docker und Docker Compose
• Model auth credentials
• Optional: Provider credentials (WhatsApp QR, Telegram bot token, Gmail OAuth)

Schnellstart

1. Hetzner VPS erstellen
2. Docker installieren
3. OpenClaw Repository klonen
4. Persistente Verzeichnisse auf dem Host anlegen
5. .env und docker-compose.yml konfigurieren
6. Benötigte Binaries in das Image “backen” (Build-Prozess)
7. docker compose up -d
8. Persistenz und Gateway-Zugriff prüfen

---

1) VPS vorbereiten

Erstelle einen Ubuntu oder Debian VPS bei Hetzner. Verbinde dich per SSH:

ssh root@DEINE_VPS_IP

Wichtig: Behandle diesen VPS als stateful Infrastructure. Er ist nicht dafür gedacht, ständig gelöscht und neu erstellt zu werden.

2) Docker installieren

Führe diese Befehle auf deinem VPS aus:

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

Prüfe die Installation:

docker --version
docker compose version

3) OpenClaw Repository klonen

Wir bauen ein eigenes Image, damit deine Binaries dauerhaft erhalten bleiben.

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

4) Persistente Verzeichnisse erstellen

Docker-Container sind flüchtig. Alles, was dauerhaft gespeichert werden soll, muss auf dem Host-System liegen.

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

# Rechte für den Container-User setzen (uid 1000):
chown -R 1000:1000 /root/.openclaw
chown -R 1000:1000 /root/.openclaw/workspace

5) Umgebungsvariablen konfigurieren

Erstelle eine .env Datei im Hauptverzeichnis des Repositories.

OPENCLAW_IMAGE=openclaw:latest
OPENCLAW_GATEWAY_TOKEN=dein-sicheres-passwort
OPENCLAW_GATEWAY_BIND=lan
OPENCLAW_GATEWAY_PORT=18789

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

GOG_KEYRING_PASSWORD=dein-keyring-passwort
XDG_CONFIG_HOME=/home/node/.openclaw

Generiere sichere Keys mit: openssl rand -hex 32. Checke diese Datei niemals in Git ein.

6) Docker Compose Konfiguration

Erstelle oder editiere die 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:
      # Empfehlung: Gateway nur lokal auf dem VPS lassen; Zugriff via SSH Tunnel.
      - "127.0.0.1:${OPENCLAW_GATEWAY_PORT}:18789"
    command:
      [
        "node",
        "dist/index.js",
        "gateway",
        "--bind",
        "${OPENCLAW_GATEWAY_BIND}",
        "--port",
        "${OPENCLAW_GATEWAY_PORT}",
      ]

7) Binaries in das Image integrieren

Das ist der wichtigste Schritt. Tools innerhalb eines laufenden Containers zu installieren, ist ein Fehler, da sie beim nächsten Neustart weg sind. Du musst sie während des Build-Prozesses fest im Image verbauen.

Hier ein Beispiel für ein Dockerfile mit gog, goplaces und wacli:

FROM node:22-bookworm

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

# Beispiel 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 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 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

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) Build und Start

docker compose build
docker compose up -d openclaw-gateway

Prüfe, ob die Binaries da sind:

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

9) Gateway verifizieren

Checke die Logs:

docker compose logs -f openclaw-gateway

Wenn dort [gateway] listening on ws://0.0.0.0:18789 steht, läuft alles. Öffne nun von deinem lokalen Rechner einen SSH-Tunnel:

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

Du kannst das Control UI jetzt unter http://127.0.0.1:18789/ aufrufen und deinen Token eingeben.

---

Was wird wo gespeichert?

Hier ist die Übersicht, wie OpenClaw seine Daten sichert:

Komponente	Ort	Mechanismus	Notiz
Gateway config	/home/node/.openclaw/	Host volume mount	Enthält openclaw.json, tokens
Model auth profiles	/home/node/.openclaw/	Host volume mount	OAuth tokens, API keys
Agent workspace	/home/node/.openclaw/workspace/	Host volume mount	Code und Artefakte
External binaries	/usr/local/bin/	Docker image	Müssen im Dockerfile stehen

Fehlerbehebung

Binaries fehlen nach Neustart: Du hast die Binaries wahrscheinlich manuell im Container installiert (docker exec ... apt install). Das funktioniert nicht dauerhaft. Du musst sie in das Dockerfile schreiben und das Image neu bauen (docker compose build).

Kein Zugriff auf das UI: Prüfe, ob dein SSH-Tunnel noch steht. Standardmäßig bindet sich das Gateway in diesem Setup an 127.0.0.1 innerhalb des Containers, was bedeutet, dass es ohne Tunnel oder Port-Freigabe (nicht empfohlen ohne Firewall) nicht von außen erreichbar ist.

---

AI Setup Assistant

What’s Next:

• Docker Deployment Guide
• Gateway Security Details