OpenClaw auf GCP Compute Engine (Docker, Production VPS Guide)

Ziel

Betreibe einen persistenten OpenClaw Gateway auf einer GCP Compute Engine VM mit Docker, dauerhaftem Zustand, eingebauten Binaries und sicherem Neustart-Verhalten.

Wenn du “OpenClaw 24/7 für ~5-12 $/Monat” willst, ist das ein zuverlässiges Setup auf Google Cloud. Die Preise variieren je nach Maschinentyp und Region; wähle die kleinste VM, die für deine Workload passt, und skaliere bei Bedarf hoch, falls du auf OOMs stößt.

Was machen wir (einfach erklärt)?

Ein GCP-Projekt erstellen und Billing aktivieren
Eine Compute Engine VM erstellen
Docker installieren (isolierte App-Runtime)
Den OpenClaw Gateway in Docker starten
~/.openclaw + ~/.openclaw/workspace auf dem Host persistieren (überlebt Neustarts/Rebuilds)
Auf die Control UI von deinem Laptop aus über einen SSH-Tunnel zugreifen

Auf den Gateway kann zugegriffen werden über:

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

Diese Anleitung verwendet Debian auf GCP Compute Engine. Ubuntu funktioniert auch; passe die Pakete entsprechend an. Für den generischen Docker-Ablauf siehe Docker.

Schnellpfad (erfahrene Betreiber)

GCP-Projekt erstellen + Compute Engine API aktivieren
Compute Engine VM erstellen (e2-small, Debian 12, 20GB)
Per SSH in die VM einloggen
Docker installieren
OpenClaw Repository klonen
Persistente Host-Verzeichnisse erstellen
.env und docker-compose.yml konfigurieren
Erforderliche Binaries einbacken, bauen und starten

Was du brauchst

GCP-Account (Free Tier berechtigt für e2-micro)
gcloud CLI installiert (oder nutze Cloud Console)
SSH-Zugriff von deinem Laptop
Grundlegende Vertrautheit mit SSH + Copy/Paste
~20-30 Minuten
Docker und Docker Compose
Model Auth Credentials
Optional Provider Credentials
- WhatsApp QR
- Telegram Bot Token
- Gmail OAuth

1) gcloud CLI installieren (oder Console nutzen)

Option A: gcloud CLI (empfohlen für Automatisierung)

Installiere von https://cloud.google.com/sdk/docs/install

Initialisieren und authentifizieren:

gcloud init
gcloud auth login

Option B: Cloud Console

Alle Schritte können über die Web-UI unter https://console.cloud.google.com durchgeführt werden.

2) Ein GCP-Projekt erstellen

CLI:

gcloud projects create my-openclaw-project --name="OpenClaw Gateway"
gcloud config set project my-openclaw-project

Aktiviere Billing unter https://console.cloud.google.com/billing (erforderlich für Compute Engine).

Aktiviere die Compute Engine API:

gcloud services enable compute.googleapis.com

Console:

Gehe zu IAM & Admin > Create Project
Benenne es und erstelle es
Aktiviere Billing für das Projekt
Navigiere zu APIs & Services > Enable APIs > suche “Compute Engine API” > Enable

3) Die VM erstellen

Maschinentypen:

Typ	Specs	Kosten	Hinweise
e2-small	2 vCPU, 2GB RAM	~12 $/Monat	Empfohlen
e2-micro	2 vCPU (shared), 1GB RAM	Free Tier berechtigt	Kann OOM unter Last

CLI:

gcloud compute instances create openclaw-gateway \
  --zone=us-central1-a \
  --machine-type=e2-small \
  --boot-disk-size=20GB \
  --image-family=debian-12 \
  --image-project=debian-cloud

Console:

Gehe zu Compute Engine > VM instances > Create instance
Name: openclaw-gateway
Region: us-central1, Zone: us-central1-a
Machine type: e2-small
Boot disk: Debian 12, 20GB
Create

4) Per SSH in die VM einloggen

CLI:

gcloud compute ssh openclaw-gateway --zone=us-central1-a

Console:

Klicke auf den “SSH”-Button neben deiner VM im Compute Engine Dashboard.

Hinweis: Die SSH-Key-Propagierung kann 1-2 Minuten nach der VM-Erstellung dauern. Wenn die Verbindung abgelehnt wird, warte und versuche es erneut.

5) Docker installieren (auf der VM)

sudo apt-get update
sudo apt-get install -y git curl ca-certificates
curl -fsSL https://get.docker.com | sudo sh
sudo usermod -aG docker $USER

Logge dich aus und wieder ein, damit die Gruppenänderung wirksam wird:

exit

Dann logge dich wieder per SSH ein:

gcloud compute ssh openclaw-gateway --zone=us-central1-a

Verifizieren:

docker --version
docker compose version

6) Das OpenClaw Repository klonen

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.

7) Persistente Host-Verzeichnisse erstellen

Docker Container sind ephemer. Alle langlebigen Zustände müssen auf dem Host liegen.

mkdir -p ~/.openclaw
mkdir -p ~/.openclaw/workspace

8) 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=/home/$USER/.openclaw
OPENCLAW_WORKSPACE_DIR=/home/$USER/.openclaw/workspace

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

Generiere starke Secrets:

openssl rand -hex 32

Committe diese Datei nicht.

9) 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: Halte den Gateway loopback-only auf der VM; Zugriff über SSH-Tunnel.
      # Um ihn öffentlich freizugeben, entferne das `127.0.0.1:`-Präfix und konfiguriere die Firewall entsprechend.
      - "127.0.0.1:${OPENCLAW_GATEWAY_PORT}:18789"

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

10) Erforderliche Binaries ins Image einbacken (kritisch)

Binaries innerhalb eines laufenden Containers zu installieren ist eine Falle. Alles, was zur Laufzeit installiert wird, geht beim Neustart verloren.

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

Die folgenden Beispiele 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 so viele Binaries wie nötig nach dem gleichen Muster installieren.

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

Das Dockerfile aktualisieren
Das Image neu bauen
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

# Füge weitere Binaries unten nach dem gleichen Muster hinzu

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"]

11) Bauen und starten

docker compose build
docker compose up -d openclaw-gateway

Binaries verifizieren:

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

12) Gateway verifizieren

docker compose logs -f openclaw-gateway

Erfolg:

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

13) Zugriff von deinem Laptop

Erstelle einen SSH-Tunnel, um den Gateway-Port weiterzuleiten:

gcloud compute ssh openclaw-gateway --zone=us-central1-a -- -L 18789:127.0.0.1:18789

Öffne in deinem Browser:

http://127.0.0.1:18789/

Füge dein Gateway Token ein.

Was persistiert wo (Source of Truth)

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

Komponente	Ort	Persistenz-Mechanismus	Hinweise
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
Skill Configs	`/home/node/.openclaw/skills/`	Host Volume Mount	Skill-Level State
Agent Workspace	`/home/node/.openclaw/workspace/`	Host Volume Mount	Code und Agent Artifacts
WhatsApp Session	`/home/node/.openclaw/`	Host Volume Mount	Bewahrt QR Login
Gmail Keyring	`/home/node/.openclaw/`	Host Volume + Password	Benötigt `GOG_KEYRING_PASSWORD`
External Binaries	`/usr/local/bin/`	Docker Image	Muss zur Build-Zeit eingebacken werden
Node Runtime	Container Filesystem	Docker Image	Wird bei jedem Image Build neu gebaut
OS Packages	Container Filesystem	Docker Image	Nicht zur Laufzeit installieren
Docker Container	Ephemer	Restartable	Kann sicher zerstört werden

Updates

Um OpenClaw auf der VM zu aktualisieren:

cd ~/openclaw
git pull
docker compose build
docker compose up -d

Troubleshooting

SSH-Verbindung abgelehnt

Die SSH-Key-Propagierung kann 1-2 Minuten nach der VM-Erstellung dauern. Warte und versuche es erneut.

OS Login Probleme

Prüfe dein OS Login Profil:

gcloud compute os-login describe-profile

Stelle sicher, dass dein Account die erforderlichen IAM-Berechtigungen hat (Compute OS Login oder Compute OS Admin Login).

Out of Memory (OOM)

Wenn du e2-micro verwendest und auf OOM stößt, upgrade auf e2-small oder e2-medium:

# Stoppe die VM zuerst
gcloud compute instances stop openclaw-gateway --zone=us-central1-a

# Ändere den Maschinentyp
gcloud compute instances set-machine-type openclaw-gateway \
  --zone=us-central1-a \
  --machine-type=e2-small

# Starte die VM
gcloud compute instances start openclaw-gateway --zone=us-central1-a

Service Accounts (Security Best Practice)

Für den persönlichen Gebrauch funktioniert dein Standard-User-Account gut.

Für Automatisierung oder CI/CD-Pipelines erstelle einen dedizierten Service Account mit minimalen Berechtigungen:

Erstelle einen Service Account:

gcloud iam service-accounts create openclaw-deploy \
  --display-name="OpenClaw Deployment"

Gewähre die Compute Instance Admin Rolle (oder eine engere Custom Role):

gcloud projects add-iam-policy-binding my-openclaw-project \
  --member="serviceAccount:[email protected]" \
  --role="roles/compute.instanceAdmin.v1"

Vermeide die Owner-Rolle für Automatisierung. Nutze das Prinzip der minimalen Berechtigung.

Siehe https://cloud.google.com/iam/docs/understanding-roles für IAM-Rollen-Details.

Nächste Schritte

Messaging Channels einrichten: Channels
Lokale Geräte als Nodes pairen: Nodes
Den Gateway konfigurieren: Gateway Konfiguration