OpenClaw auf GCP Compute Engine (Docker Guide)

Ich kenne das Problem: Du hast dein Setup lokal auf einem Raspberry Pi oder deinem Laptop laufen, aber sobald die Internetverbindung kurz weg ist oder der Rechner in den Standby geht, bricht alles zusammen. Wenn du OpenClaw wirklich 24/7 nutzen willst, ohne ständig nach dem Rechten zu sehen, ist ein kleiner VPS in der Cloud die beste Lösung.

Google Cloud (GCP) bietet hier eine sehr stabile Basis. Für etwa 5 bis 12 Euro im Monat bekommst du ein System, das einfach läuft. In diesem Guide zeige ich dir, wie du das OpenClaw Gateway mit Docker auf einer Compute Engine VM installierst, damit deine State-Daten erhalten bleiben und die Binaries direkt im Image stecken.

Voraussetzungen

• Einen GCP Account (e2-micro ist oft im Free Tier enthalten)
• Installierte gcloud CLI oder Zugriff auf die Cloud Console
• SSH-Zugriff von deinem Rechner
• Grundkenntnisse in SSH und Copy-Paste
• Etwa 20-30 Minuten Zeit
• Docker und Docker Compose
• API-Credentials für deine Modelle
• Provider-Daten (WhatsApp QR, Telegram Token oder Gmail OAuth)

Schnellstart

Wenn du dich mit GCP auskennst, ist das hier dein Pfad:

1. GCP Projekt erstellen und Compute Engine API aktivieren.
2. VM erstellen (e2-small, Debian 12, 20GB).
3. Per SSH auf die VM verbinden und Docker installieren.
4. OpenClaw Repository klonen und Verzeichnisse für Persistence erstellen.
5. .env und docker-compose.yml konfigurieren.
6. Benötigte Binaries in das Dockerfile schreiben, Build starten und Gateway launchen.

---

1) gcloud CLI installieren

Option A: gcloud CLI (empfohlen) Installiere das Tool von der offiziellen Seite. Danach initialisierst du den Zugriff:

gcloud init
gcloud auth login

Option B: Cloud Console Du kannst alle Schritte auch im Browser unter console.cloud.google.com erledigen.

2) GCP Projekt vorbereiten

Erstelle ein Projekt und aktiviere die Abrechnung:

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

Aktiviere die Compute Engine API:

gcloud services enable compute.googleapis.com

3) Die VM erstellen

Wähle den passenden Maschinentyp:

• e2-small: 2 vCPU, 2GB RAM (Empfohlen für stabilen Betrieb)
• e2-micro: 2 vCPU, 1GB RAM (Free Tier fähig, kann aber bei Last abstürzen)

Erstelle die Instanz per 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

4) Per SSH verbinden

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

Falls die Verbindung abgelehnt wird, warte kurz. Es dauert manchmal ein bis zwei Minuten, bis die SSH-Keys auf der neuen VM verteilt sind.

5) Docker installieren

Führe diese Befehle auf der VM aus:

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 kurz aus und wieder ein, damit die Docker-Rechte greifen:

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

6) Repository klonen

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

7) Persistence vorbereiten

Docker Container sind flüchtig. Damit deine Daten einen Neustart überleben, brauchen wir Verzeichnisse auf dem Host:

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

8) Umgebungsvariablen konfigurieren

Erstelle eine .env Datei im Hauptverzeichnis:

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

OPENCLAW_CONFIG_DIR=/home/$USER/.openclaw
OPENCLAW_WORKSPACE_DIR=/home/$USER/.openclaw/workspace

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

9) Docker Compose Setup

Erstelle 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:
      - "127.0.0.1:${OPENCLAW_GATEWAY_PORT}:18789"
    command:
      [
        "node",
        "dist/index.js",
        "gateway",
        "--bind",
        "${OPENCLAW_GATEWAY_BIND}",
        "--port",
        "${OPENCLAW_GATEWAY_PORT}",
      ]

10) Binaries fest im Image verbauen

Das ist ein wichtiger Punkt: Wenn du Binaries erst zur Laufzeit im Container installierst, sind sie nach einem Neustart weg. Du musst sie im Dockerfile “backen”.

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/*

# 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

# 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

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

11) Build und Start

docker compose build
docker compose up -d openclaw-gateway

Prüfe danach, ob die Binaries da sind: docker compose exec openclaw-gateway which gog

12) Zugriff vom Laptop

Da wir den Port nur auf 127.0.0.1 gebunden haben (Sicherheit!), musst du einen SSH-Tunnel nutzen:

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

Jetzt kannst du im Browser http://127.0.0.1:18789/ aufrufen und dein Gateway Token eingeben.

Fehlerbehebung

• SSH Connection Refused: Warte zwei Minuten nach dem Erstellen der VM. Die Keys brauchen Zeit.
• Out of Memory (OOM): Wenn die VM abstürzt, nutzt du wahrscheinlich e2-micro. Upgrade auf e2-small.
• Binaries fehlen: Hast du das Dockerfile angepasst und docker compose build ausgeführt? Ohne Build-Schritt landen neue Tools nicht im Image.
• OS Login Probleme: Prüfe deine IAM-Rechte. Du brauchst die Rolle “Compute OS Login”.

Du hast Fragen zum Setup? Nutze den AI Setup Assistant für schnelle Hilfe.

Nächste Schritte

• Verbinde deine Messaging Kanäle: Channels
• Füge lokale Geräte als Nodes hinzu: Nodes
• Passe die Gateway-Konfiguration an: Gateway Konfiguration
• Verwalte deine API-Keys sicher: Security