OpenClaw noch nicht installiert? Klicken Sie hier fur die Ein-Klick-Installationsanleitung
curl -fsSL https://openclaw.ai/install.sh | bash
iwr -useb https://openclaw.ai/install.ps1 | iex
curl -fsSL https://openclaw.ai/install.cmd -o install.cmd && install.cmd && del install.cmd
Bedenken wegen moglicher Auswirkungen auf Ihren Computer? ClawTank lauft in der Cloud ohne Installation -- kein Risiko versehentlicher Dateiloschung
Key Findings
  • Das OpenClaw Gateway ist die zentrale Schaltstelle des gesamten Agentensystems. Es lauft uber das WebSocket-Protokoll auf dem Standard-Port 18789 und ist verantwortlich fur Aufgabenplanung, Node-Verwaltung und LLM-Request-Routing[1]
  • Das Gateway bietet zwei Betriebsmodi: Local und Remote -- der Local-Modus bindet ausschliesslich an 127.0.0.1 und eignet sich fur die persoenliche Entwicklung; der Remote-Modus unterstutzt mit Token-Authentifizierung den gerateübergreifenden und netzwerkübergreifenden Zugriff[3]
  • Der Headless-Betriebsmodus ermoglicht in Kombination mit systemd oder Docker-Containerisierung einen stabilen 24/7-Dienst auf Cloud-Servern ohne grafische Oberflache
  • Tailscale bietet einen konfigurationsfreien, sicheren VPN-Tunnel, der die Komplexitat von Port-Forwarding und dynamischem DNS eliminiert -- die beste Wahl fur personlichen und Kleinteam-Fernzugriff auf das Gateway[4]
  • Der Gateway Token ist der einzige Authentifizierungsmechanismus im Remote-Modus. Es wird empfohlen, automatische Rotation zu aktivieren und TLS-verschlusselte Ubertragung einzusetzen, um unbefugten Zugriff auf das Agentensystem zu verhindern[5]

Wenn Sie zum ersten Mal das OpenClaw-Tutorial starten, startet das System automatisch einen Gateway-Dienst auf Ihrem lokalen Rechner. Moglicherweise haben Sie seine Existenz nie bemerkt -- er lauft leise im Hintergrund, empfangt jeden Befehl, den Sie uber die CLI oder das Web-UI senden, koordiniert die Aufgabenausfuhrung durch Nodes und liefert die Ergebnisse zuruck. Diese scheinbar transparente Komponente ist tatsachlich das Nervenzentrum der gesamten OpenClaw-Agentenarchitektur.[1]

Sobald Ihre Anforderungen uber „ein paar Aufgaben auf dem eigenen Laptop ausfuhren" hinausgehen -- beispielsweise wenn Sie den Agenten vom Smartphone aus fernsteuern mochten, einen 24/7-Automatisierungs-Workflow auf einem Cloud-VPS bereitstellen oder Teammitglieder ein gemeinsames Gateway nutzen lassen wollen -- mussen Sie die Modusumschaltung, Deployment-Strategien und Sicherheitseinstellungen des Gateways im Detail verstehen.

Dieser Artikel beginnt bei der architektonischen Rolle des Gateways und behandelt systematisch die Konfiguration der beiden Modi Local und Remote, den vollstandigen Ablauf des Headless-Cloud-Deployments, den sicheren Fernzugriff uber Tailscale, den Gateway-Token-Authentifizierungsmechanismus sowie Strategien zur Fehlerbehebung haufiger Probleme in Produktionsumgebungen. Ob Sie ein Entwickler sind, der OpenClaw gerade erst kennenlernt, oder ein DevOps-Ingenieur, der ein Cloud-Deployment plant -- dieser Leitfaden bietet Ihnen die benotigten technischen Referenzen.

1. Was ist das Gateway? Seine Rolle in der OpenClaw-Architektur

Das Gateway ist der einheitliche Zugangspunkt und Koordinationskern des OpenClaw-Agentensystems. Es lauft als WebSocket-Server auf Port 18789 und ist der einzige Knotenpunkt fur die Kommunikation zwischen allen Nodes, Channels und externen Clients.[1]

1.1 Position des Gateways in der Vier-Schichten-Architektur

Die Laufzeitarchitektur von OpenClaw besteht aus vier Schichten:

Die Verantwortung des Gateways in dieser Architektur geht weit uber „Nachrichtenweiterleitung" hinaus: Es verwaltet eine Task Queue fur die Aufgabenplanung, managt den Kontextspeicher und die Gesprächshistorie jedes Workspace, koordiniert API-Anfragen an verschiedene LLM-Anbieter (Ratenbegrenzung, Schlusselrouting) und verwaltet den Verbindungslebenszyklus der Nodes (Registrierung, Heartbeat, Wiederverbindung nach Trennung).

1.2 WebSocket-Protokoll und Port 18789

Das Gateway verwendet WebSocket anstelle von herkommlichem HTTP als Kernkommunikationsprotokoll, da AI-Agenten-Workflows ihrem Wesen nach bidirektional und langlebig verbunden sind -- Nodes mussen Aufgabenzuweisungen in Echtzeit empfangen, und das Gateway muss Ausfuhrungsfortschritte und Ergebnisse in Echtzeit erhalten. Die Vollduplex-Eigenschaft von WebSocket passt perfekt zu dieser Anforderung.[2]

Der Standard-Port 18789 liegt im registrierten Portbereich der IANA (1024--49151) und kollidiert weniger wahrscheinlich mit gangigen Diensten. Das Gateway stellt gleichzeitig auf diesem Port HTTP-Endpunkte fur Health-Checks (/health), Statusabfragen (/status) und REST-API-Zugriff bereit.

Sie konnen den Betriebszustand des Gateways jederzeit mit folgendem Befehl uberprufen:

# Gateway-Betriebsstatus anzeigen
openclaw gateway status

# Erwartete Ausgabe
# Gateway Status: running
# Mode: local
# Address: ws://127.0.0.1:18789
# Uptime: 2h 15m 32s
# Connected Nodes: 1
# Active Tasks: 0
# Queued Tasks: 0

Falls das Gateway nicht lauft, gibt openclaw gateway status Gateway Status: stopped zuruck. Sie konnen es manuell starten:

# Gateway manuell starten
openclaw gateway start

# Gateway manuell stoppen
openclaw gateway stop

# Gateway neu starten
openclaw gateway restart

2. Local vs. Remote Modus: Unterschiede und Auswahl

Das OpenClaw Gateway bietet zwei zentrale Betriebsmodi, die zwei grundverschiedenen Anwendungsszenarien entsprechen. Das Verstandnis ihrer Unterschiede ist der erste Schritt zum korrekten Deployment.[3]

2.1 Local-Modus

Bind-Adresse: 127.0.0.1:18789 (nur lokale Loopback-Schnittstelle)

Der Local-Modus ist der Standardzustand nach der Installation. Das Gateway akzeptiert nur Verbindungen vom selben Rechner; externes Netzwerk hat keinen Zugriff. Dies ist die sicherste Konfiguration, da die Angriffsflache auf die lokale Betriebssystemebene beschrankt ist.[5]

Geeignete Szenarien:

Einschrankungen:

2.2 Remote-Modus

Bind-Adresse: 0.0.0.0:18789 (alle Netzwerkschnittstellen) oder bestimmte Schnittstelle

Der Remote-Modus erlaubt Verbindungen aus jedem Netzwerk. Nach der Aktivierung erfordert das Gateway die Einrichtung einer Token-Authentifizierung, um unbefugten Zugriff zu verhindern.[4]

Geeignete Szenarien:

Einschrankungen:

2.3 Schnellvergleichstabelle der Modi

Aspekt Local-Modus Remote-Modus
Bind-Adresse 127.0.0.1 0.0.0.0 oder bestimmte Schnittstelle
Authentifizierung Keine (lokal bereits isoliert) Gateway Token erforderlich
Externer Zugriff Nicht erlaubt Erlaubt (mit Authentifizierung)
TLS-Empfehlung Nicht erforderlich Dringend empfohlen
Geeignete Groessenordnung Einzelperson, Einzelrechner Mehrere Personen, mehrere Gerate
Initialer Einrichtungsaufwand Keine Konfiguration Mittel

3. Local-Modus-Konfiguration

Der Local-Modus ist der einfachste Ausgangspunkt. Wenn Sie OpenClaw frisch installiert haben, lauft das Gateway standardmassig im Local-Modus -- Sie mussen keine zusatzliche Konfiguration vornehmen.[2]

3.1 Aktuellen Modus uberprufen

# Aktuellen Gateway-Modus anzeigen
openclaw config get gateway.mode

# Erwartete Ausgabe
# gateway.mode = "local"

3.2 Explizit auf Local-Modus setzen

Falls Sie den Modus zuvor gewechselt haben oder sicherstellen mochten, dass der Local-Modus aktiv ist:

# Gateway auf Local-Modus setzen
openclaw config set gateway.mode local

# Gateway neu starten, damit die Einstellung wirksam wird
openclaw gateway restart

3.3 Gateway-Listening-Adresse uberprufen

Nach der Konfiguration stellen Sie sicher, dass das Gateway tatsachlich nur an die lokale Loopback-Schnittstelle gebunden ist:

# Gateway-Status anzeigen
openclaw gateway status

# Port-Bindung mit System-Tools uberprufen (macOS / Linux)
lsof -i :18789

# Erwartet: Bindung an 127.0.0.1:18789
# COMMAND   PID     USER   FD   TYPE  SIZE/OFF NODE NAME
# openclaw  12345   user   8u   IPv4  0t0      TCP  127.0.0.1:18789 (LISTEN)

3.4 Port anpassen

Der Standard-Port 18789 kollidiert in den meisten Fallen nicht. Wenn jedoch ein anderer Dienst in Ihrer Umgebung diesen Port belegt, konnen Sie ihn andern:

# Gateway-Port andern
openclaw config set gateway.port 28789

# Nach Neustart wirksam
openclaw gateway restart

# Neuen Port bestatigen
openclaw gateway status
# Gateway Status: running
# Mode: local
# Address: ws://127.0.0.1:28789

Nach der Port-Anderung erkennen alle CLI-Interaktionen den neuen Port automatisch. Wenn Sie jedoch externe Tools (wie benutzerdefinierte Skripte oder API-Clients) zur Verbindung mit dem Gateway verwenden, muss die Verbindungsadresse entsprechend aktualisiert werden.

3.5 Gateway-Konfigurationsabschnitt in openclaw.json

Die oben genannten CLI-Befehle haben denselben Effekt wie die direkte Bearbeitung der entsprechenden Felder in ~/.openclaw/openclaw.json:

// ~/.openclaw/openclaw.json (Gateway-bezogene Konfiguration)
{
  "gateway": {
    "mode": "local",           // "local" oder "remote"
    "port": 18789,             // Gateway-Listening-Port
    "host": "127.0.0.1",       // Im Local-Modus automatisch auf 127.0.0.1 gesetzt
    "websocket_path": "/ws",   // WebSocket-Endpunkt-Pfad
    "auto_start": true,        // Gateway beim OpenClaw-Start automatisch starten
    "log_level": "info"        // Log-Level: debug, info, warn, error
  }
}

Empfehlung: Verwenden Sie bevorzugt den CLI-Befehl openclaw config set zur Konfigurationsanderung. Er ubernimmt automatisch Formatvalidierung und Abhangigkeitsprufung und vermeidet Syntaxfehler bei der manuellen JSON-Bearbeitung.[3]

4. Remote-Modus-Konfiguration

Der Remote-Modus ist der entscheidende Schritt, um das OpenClaw Gateway im Netzwerk verfugbar zu machen. Ob gerateübergreifender Zugriff, Cloud-Deployment oder Teamzusammenarbeit Ihr Ziel ist -- der folgende Konfigurationsprozess muss durchlaufen werden.[4]

4.1 Remote-Modus aktivieren

# Auf Remote-Modus umschalten
openclaw config set gateway.mode remote

# Das System fordert Sie auf, einen Gateway Token einzurichten (beim ersten Umschalten)
# > Remote mode requires a gateway token for authentication.
# > Run 'openclaw doctor --generate-gateway-token' to create one.

4.2 Gateway Token generieren und einrichten

Der Gateway Token ist die einzige Authentifizierungsinformation im Remote-Modus. Alle Clients und Nodes, die sich mit dem Gateway verbinden, mussen diesen Token bei der Verbindung angeben.[5]

# Neuen Gateway Token generieren
openclaw doctor --generate-gateway-token

# Ausgabebeispiel
# Generated gateway token: ogt_a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6
# Token has been saved to your configuration.
#
# To connect from another device, use:
#   openclaw config set gateway.url wss://YOUR_IP:18789/ws
#   openclaw config set gateway.token ogt_a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6

4.3 Remote-URL konfigurieren

Auf dem Client-Rechner, der sich mit dem Remote-Gateway verbinden soll, richten Sie die Gateway-URL und den Token ein:

# Auf dem Remote-Client konfigurieren (z. B. Ihr Smartphone oder ein anderer Computer)
openclaw config set gateway.url wss://your-server-ip:18789/ws
openclaw config set gateway.token ogt_a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6

# Verbindung testen
openclaw gateway health
# Gateway healthy: wss://your-server-ip:18789/ws
# Authentication: OK

4.4 Remote-Konfiguration fur Cloud-Deployment

Wenn das Gateway auf einem Cloud-VPS bereitgestellt wird (z. B. AWS EC2, GCP Compute Engine, Linode, DigitalOcean), wird die Kombination mit einem Reverse-Proxy und TLS empfohlen:

# Auf dem Cloud-Server
openclaw config set gateway.mode remote
openclaw config set gateway.host 127.0.0.1    # Gateway weiterhin lokal binden
openclaw config set gateway.port 18789
openclaw doctor --generate-gateway-token

# Nginx oder Caddy ubernehmen am Frontend die TLS-Terminierung und Weiterleitung
# Client-Verbindungsadresse: wss://gateway.yourdomain.com/ws

Wichtiges Sicherheitsprinzip: Auch im Remote-Modus wird davon abgeraten, das Gateway direkt auf 0.0.0.0 binden und im offentlichen Internet freigeben zu lassen. Die korrekte Architektur sieht vor, dass das Gateway weiterhin an 127.0.0.1 gebunden bleibt und ein Nginx/Caddy-Reverse-Proxy am Frontend externe TLS-Verbindungen akzeptiert und uber den lokalen Loopback an das Gateway weiterleitet.[7]

4.5 Vollstandiges openclaw.json Remote-Konfigurationsbeispiel

// ~/.openclaw/openclaw.json (vollstandige Remote-Modus-Konfiguration)
{
  "gateway": {
    "mode": "remote",
    "port": 18789,
    "host": "127.0.0.1",
    "websocket_path": "/ws",
    "auto_start": true,
    "log_level": "info",
    "token": "ogt_a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6",
    "allowed_origins": [
      "https://gateway.yourdomain.com",
      "https://app.yourdomain.com"
    ],
    "rate_limit": {
      "enabled": true,
      "max_requests_per_minute": 120,
      "max_connections": 50
    }
  }
}

5. Headless-Betrieb: Gateway-Deployment in Umgebungen ohne grafische Oberflache

Der Standard-Startprozess von OpenClaw versucht, GUI-Komponenten zu initialisieren (System-Tray-Symbol, Benachrichtigungsfenster usw.). Auf Linux-Servern oder in Docker-Containern ohne Desktop-Umgebung fuhrt dies zu einem Startfehler. Der Headless-Modus uberspringt jegliche GUI-Initialisierung und startet nur den Gateway-Kerndienst.[6]

5.1 Grundlegender Headless-Start

# Methode 1: Vordergrundausfuhrung (empfohlen fur screen/tmux)
openclaw gateway run

# Methode 2: Umgebungsvariable
export OPENCLAW_HEADLESS=true
openclaw gateway run

# Methode 3: In Konfigurationsdatei schreiben und starten
openclaw config set gateway.headless true
openclaw gateway run

5.2 Persistenz mit screen/tmux

Prozesse, die in einer SSH-Sitzung gestartet werden, werden beim Trennen der SSH-Verbindung beendet. Die einfachste Persistenzlosung ist screen oder tmux:

# Mit screen
screen -S openclaw-gw
OPENCLAW_HEADLESS=true openclaw gateway run
# Ctrl+A, dann D drucken zum Trennen
# Spater wieder verbinden: screen -r openclaw-gw

# Mit tmux (empfohlen)
tmux new-session -d -s openclaw -n gateway
tmux send-keys -t openclaw:gateway \
'OPENCLAW_HEADLESS=true openclaw gateway run' Enter

# Log-Monitoring-Fenster hinzufugen
tmux new-window -t openclaw -n logs
tmux send-keys -t openclaw:logs \
'tail -f ~/.openclaw/logs/gateway.log' Enter

# Wieder verbinden: tmux attach -t openclaw

5.3 systemd-Dienstkonfiguration (empfohlen fur Produktionsumgebungen)

Fur Produktionsumgebungen, die automatischen Start beim Booten, automatischen Neustart und Systemlog-Integration benotigen, ist systemd die Standardwahl:

# /etc/systemd/system/openclaw-gateway.service

[Unit]
Description=OpenClaw Gateway Service
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=openclaw
Group=openclaw
WorkingDirectory=/opt/openclaw
Environment="OPENCLAW_HEADLESS=true"
Environment="OPENCLAW_GATEWAY_HOST=127.0.0.1"
Environment="OPENCLAW_GATEWAY_PORT=18789"
Environment="OPENCLAW_LOG_LEVEL=info"
EnvironmentFile=-/opt/openclaw/.env
ExecStart=/usr/local/bin/openclaw gateway run
ExecReload=/bin/kill -HUP $MAINPID
Restart=always
RestartSec=10
StandardOutput=journal
StandardError=journal
SyslogIdentifier=openclaw-gateway

# Sicherheitshartung
NoNewPrivileges=true
ProtectSystem=strict
ProtectHome=true
ReadWritePaths=/opt/openclaw/data /opt/openclaw/logs

# Ressourcenbegrenzungen
LimitNOFILE=65536
LimitNPROC=4096

[Install]
WantedBy=multi-user.target
# Dedizierten Systembenutzer anlegen
sudo useradd -r -s /usr/sbin/nologin -d /opt/openclaw openclaw
sudo mkdir -p /opt/openclaw/{data,logs,config}
sudo chown -R openclaw:openclaw /opt/openclaw

# Dienst aktivieren und starten
sudo systemctl daemon-reload
sudo systemctl enable openclaw-gateway
sudo systemctl start openclaw-gateway

# Status und Logs anzeigen
sudo systemctl status openclaw-gateway
sudo journalctl -u openclaw-gateway -f

5.4 Docker-Container-Deployment

Docker bietet die Vorteile von Umgebungsisolierung und Versionsverwaltung und ist die gangige Losung fur Cloud-Deployments:

# Dockerfile
FROM python:3.11-slim-bookworm

RUN apt-get update && apt-get install -y --no-install-recommends \
curl git ca-certificates && rm -rf /var/lib/apt/lists/*

RUN groupadd -r openclaw && useradd -r -g openclaw -d /app openclaw
WORKDIR /app

RUN pip install --no-cache-dir openclaw

RUN mkdir -p /app/data /app/logs && chown -R openclaw:openclaw /app
USER openclaw

ENV OPENCLAW_HEADLESS=true \
OPENCLAW_GATEWAY_HOST=0.0.0.0 \
OPENCLAW_GATEWAY_PORT=18789 \
OPENCLAW_DATA_DIR=/app/data \
OPENCLAW_LOG_DIR=/app/logs

EXPOSE 18789

HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
CMD curl -f http://localhost:18789/health || exit 1

CMD ["openclaw", "gateway", "start", "--headless"]
# docker-compose.yml
version: '3.8'

services:
openclaw-gateway:
  build: .
  container_name: openclaw-gw
  restart: unless-stopped
  env_file:
    - .env.gateway
  volumes:
    - openclaw-data:/app/data
    - openclaw-logs:/app/logs
  expose:
    - "18789"
  healthcheck:
    test: ["CMD", "curl", "-f", "http://localhost:18789/health"]
    interval: 30s
    timeout: 10s
    retries: 3

nginx:
  image: nginx:1.25-alpine
  container_name: openclaw-nginx
  restart: unless-stopped
  ports:
    - "443:443"
    - "80:80"
  volumes:
    - ./nginx.conf:/etc/nginx/conf.d/default.conf:ro
    - /etc/letsencrypt:/etc/letsencrypt:ro
  depends_on:
    openclaw-gateway:
      condition: service_healthy

volumes:
openclaw-data:
openclaw-logs:
# Erstellen und starten
docker compose up -d --build

# Logs anzeigen
docker compose logs -f openclaw-gateway

# Gateway neu starten
docker compose restart openclaw-gateway

# Zur Fehlersuche in den Container einsteigen
docker compose exec openclaw-gateway /bin/bash

6. Tailscale-Fernzugriff: Konfigurationsfreies sicheres VPN

Herkommliche Fernzugriffsmethoden (Port-Forwarding, dynamisches DNS, selbstsignierte Zertifikate) sind fur einzelne Entwickler zu aufwendig und fehleranfallig. Tailscale bietet eine minimalistische Alternative: einen sofort einsatzbereiten WireGuard-VPN-Tunnel, der alle Ihre Gerate so erscheinen lasst, als befanden sie sich im selben lokalen Netzwerk.[4]

6.1 Warum Tailscale

6.2 Einrichtungsprozess

# Schritt 1: Tailscale auf dem Gateway-Server installieren
curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up

# Schritt 2: Tailscale-IP uberprufen
tailscale ip -4
# Beispiel: 100.64.0.1

# Schritt 3: Gateway fur Tailscale-Schnittstelle konfigurieren
openclaw config set gateway.mode remote
openclaw config set gateway.host 100.64.0.1
openclaw doctor --generate-gateway-token
openclaw gateway restart

# Schritt 4: Tailscale auf dem Client-Gerat installieren und verbinden
# (macOS / Windows / iOS / Android werden alle unterstutzt)
sudo tailscale up

# Schritt 5: Gateway-Verbindung auf dem Client konfigurieren
openclaw config set gateway.url ws://my-server.tailnet-name.ts.net:18789/ws
openclaw config set gateway.token ogt_your_token_here

# Verbindung testen
openclaw gateway health

6.3 Tailscale ACL-Zugriffskontrolle

Tailscales ACL (Access Control List) ermoglicht Ihnen die prazise Steuerung, welche Gerate auf das Gateway zugreifen konnen:

// Tailscale ACL Policy (in der Tailscale Admin Console konfigurieren)
{
"acls": [
  {
    "action": "accept",
    "src": ["tag:openclaw-client"],
    "dst": ["tag:openclaw-gateway:18789"]
  }
],
"tagOwners": {
  "tag:openclaw-gateway": ["autogroup:admin"],
  "tag:openclaw-client": ["autogroup:admin"]
}
}

6.4 Tailscale Funnel (Fortgeschritten: Offentliche Freigabe)

Wenn Sie externen Benutzern ohne Tailscale-Installation Zugriff auf Ihr Gateway gewahren mussen (z. B. fur eine Demo beim Kunden), konnen Sie Tailscale Funnel zur temporaren offentlichen Freigabe verwenden:

# Gateway temporar im Internet freigeben (automatisches HTTPS)
tailscale funnel 18789

# Externe Benutzer konnen uber folgende Adresse zugreifen
# https://my-server.tailnet-name.ts.net/

# Funnel deaktivieren
tailscale funnel --reset

Hinweis: Funnel macht Ihr Gateway im offentlichen Internet zuganglich. Selbst mit Tailscales HTTPS-Verschlusselung muss unbedingt ein Gateway Token eingerichtet sein, um unbefugten Zugriff zu verhindern.[8]

7. Gateway-Token-Sicherheit

Der Gateway Token ist im Remote-Modus die letzte Verteidigungslinie zum Schutz Ihres gesamten Computers. Der OpenClaw-Agent kann Shell-Befehle ausfuhren, das Dateisystem manipulieren und den Browser steuern -- das bedeutet, dass jeder, der Ihren Gateway Token erlangt, theoretisch alles mit Ihrem Rechner anstellen kann.[5][7]

7.1 Token-Generierung und Format

# Neuen Token generieren
openclaw doctor --generate-gateway-token

# Token-Format: Prafix ogt_ + 32 zufallige Zeichen
# Beispiel: ogt_a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6

# Token manuell festlegen (nicht empfohlen, ausser bei speziellen Anforderungen)
openclaw config set gateway.token "your-custom-token-here"

7.2 Token-Rotation

Die regelmaessige Erneuerung des Tokens ist eine bewahrt Sicherheitspraxis, insbesondere in folgenden Situationen:

# Token neu generieren (alter Token wird sofort ungultig)
openclaw doctor --generate-gateway-token --force

# Alle verbundenen Clients und Nodes werden zwangsweise getrennt
# Der neue Token muss auf allen Clients aktualisiert werden
openclaw config set gateway.token ogt_new_token_here

7.3 Best Practices fur die Sicherheit

# Letzte Authentifizierungsfehler anzeigen
openclaw logs --follow --limit 100

# Authentifizierungsfehler-Sperre konfigurieren (nach 5 aufeinanderfolgenden Fehlversuchen Quell-IP fur 15 Minuten sperren)
openclaw config set gateway.security.max_auth_failures 5
openclaw config set gateway.security.lockout_duration_minutes 15

7.4 Token-Verwaltung uber Umgebungsvariablen

Bei automatisierten Deployments sollte der Token uber Umgebungsvariablen injiziert und nicht in Konfigurationsdateien geschrieben werden:

# .env.gateway (NICHT in die Versionskontrolle einchecken)
OPENCLAW_GATEWAY_TOKEN=ogt_a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...

# In systemd verwenden
EnvironmentFile=/opt/openclaw/.env.gateway

# In Docker Compose verwenden
env_file:
- .env.gateway

# Dateiberechtigungen fur .env.gateway sicherstellen
chmod 600 /opt/openclaw/.env.gateway
chown openclaw:openclaw /opt/openclaw/.env.gateway

8. Haufige Probleme und Fehlerbehebung

Im Folgenden sind die haufigsten Probleme beim Deployment des OpenClaw Gateway und ihre Losungen zusammengefasst.[3]

8.1 Port-Konflikt

Symptom: Gateway-Start schlagt fehl, Log zeigt Address already in use: 0.0.0.0:18789

# Pruefen, wer Port 18789 belegt
sudo lsof -i :18789
# oder
sudo ss -tlnp | grep 18789

# Haufige Ursache: Vorheriger Gateway-Prozess wurde nicht ordnungsgemaess beendet
# Losung 1: Belegenden Prozess beenden
sudo kill -9 $(lsof -t -i :18789)

# Losung 2: Anderen Port verwenden
openclaw config set gateway.port 28789
openclaw gateway restart

8.2 Remote-Modus-Verbindungsfehler

Symptom: Client kann keine Verbindung zum Remote-Gateway herstellen, zeigt Connection refused oder Connection timed out

# Fehlersuche Schritt 1: Pruefen, ob Gateway lauft
openclaw gateway status

# Fehlersuche Schritt 2: Gateway-Listening-Adresse pruefen
ss -tlnp | grep 18789
# Wenn 127.0.0.1:18789 angezeigt wird, akzeptiert das Gateway nur lokale Verbindungen
# Es muss ein Reverse-Proxy oder Tailscale verwendet werden

# Fehlersuche Schritt 3: Firewall-Regeln pruefen
sudo ufw status
sudo iptables -L -n | grep 18789

# Fehlersuche Schritt 4: Netzwerkkonnektivitat testen
# Auf dem Client ausfuhren
curl -v http://your-server-ip:18789/health
# Oder (bei Verwendung eines Reverse-Proxy)
curl -v https://gateway.yourdomain.com/health

# Fehlersuche Schritt 5: Pruefen, ob der Token korrekt ist
openclaw config get gateway.token

8.3 WebSocket-Verbindungsabbruch

Symptom: Aufgabe wird wahrend der Ausfuhrung unterbrochen, Log zeigt WebSocket connection closed unexpectedly

# Haufigste Ursache: Timeout-Einstellung des Reverse-Proxy zu kurz

# Nginx-Korrektur: proxy_read_timeout erhoehen
# /etc/nginx/conf.d/openclaw.conf
location /ws {
  proxy_pass http://127.0.0.1:18789;
  proxy_http_version 1.1;
  proxy_set_header Upgrade $http_upgrade;
  proxy_set_header Connection "upgrade";
  proxy_read_timeout 3600s;    # Mindestens 1 Stunde
  proxy_send_timeout 3600s;
  proxy_connect_timeout 30s;
}

# Gateway-seitige Korrektur: Heartbeat-Intervall anpassen
openclaw config set gateway.websocket.ping_interval 30
openclaw config set gateway.websocket.ping_timeout 10

8.4 Headless-Startfehler

Symptom: Beim Start auf einem Server ohne GUI erscheint cannot open display oder Gtk initialization failed

# Vordergrundmodus verwenden (keine GUI erforderlich)
openclaw gateway run

# Oder Umgebungsvariablen setzen
export OPENCLAW_HEADLESS=true
export DISPLAY=    # DISPLAY-Variable leeren

# Node.js-Version pruefen (Version 22+ erforderlich)
node --version

# Pruefen, ob OpenClaw korrekt installiert ist
openclaw --version

8.5 Kurzreferenz fur Gateway-Statusabfragen

# Vollstandiger Statusbericht
openclaw gateway status --deep

# JSON-Ausgabe (zur Skriptverarbeitung geeignet)
openclaw gateway status --json

# Health-Check (geeignet fur Monitoring-Systeme)
openclaw gateway health
curl -s http://127.0.0.1:18789/health | python3 -m json.tool

9. Empfehlungen fur Cloud-Deployment-Architekturen

Basierend auf Teamgroesse und Zuverlassigkeitsanforderungen folgen Empfehlungen fur drei Cloud-Deployment-Architekturen.

9.1 Personlich / Kleine Projekte: VPS + Caddy

Die kostengunstigste Deployment-Methode mit dem geringsten Wartungsaufwand. Geeignet fur einzelne Entwickler oder kleine Teams von 1--3 Personen.

# Architektur-Topologie
[Client-Gerate] --wss--> [Caddy :443] --> [Gateway :18789] --> [LLM APIs]

# Caddyfile (automatisches TLS)
gateway.yourdomain.com {
reverse_proxy /ws localhost:18789 {
  header_up Upgrade {http.upgrade}
  header_up Connection "Upgrade"
  transport http {
    read_timeout 1h
    write_timeout 1h
  }
}
reverse_proxy localhost:18789
}

# Empfohlene VPS-Spezifikation: 2 vCPU / 4 GB RAM / 40 GB SSD
# Monatliche Kosten: ca. $5--$20 USD (Linode, DigitalOcean, Vultr)

9.2 Mittelgrosse Teams: Docker Compose + Nginx + Monitoring

Geeignet fur Teams von 5--20 Personen, die eine formelle Monitoring- und Logging-Infrastruktur benotigen.

# Architektur-Topologie
[Mehrere Clients] --wss--> [Nginx :443]
                          |
                    [Gateway :18789]
                          |
              +-----------+-----------+
              |           |           |
          [Prometheus] [Grafana]  [Loki]

# Deployment-Befehl
docker compose -f docker-compose.yml \
-f docker-compose.monitoring.yml up -d

9.3 Produktionsumgebungs-Checkliste

Bevor Sie das Gateway in die Produktionsumgebung bringen, prufen Sie jeden Punkt:[7][8]

Sicherheit

Zuverlassigkeit

Leistung

Ressourcenplanung

Groessenordnung Parallele Aufgaben CPU Arbeitsspeicher Speicher
Personlich 1--3 2 vCPU 4 GB 20 GB SSD
Kleines Team 5--10 4 vCPU 8 GB 50 GB SSD
Unternehmen 20+ 8+ vCPU 16+ GB 200 GB NVMe

9.4 Automatisches Backup-Skript

#!/bin/bash
# /opt/scripts/backup-openclaw.sh
set -euo pipefail

BACKUP_DIR="/backups/openclaw"
DATE=$(date +%Y%m%d-%H%M%S)
RETENTION_DAYS=30

mkdir -p "$BACKUP_DIR"

# Workspace-Daten sichern
tar czf "$BACKUP_DIR/workspace-$DATE.tar.gz" \
/opt/openclaw/data/

# Konfiguration sichern (ohne sensible .env-Dateien)
tar czf "$BACKUP_DIR/config-$DATE.tar.gz" \
/opt/openclaw/config/

# Alte Backups bereinigen
find "$BACKUP_DIR" -name "*.tar.gz" \
-mtime +$RETENTION_DAYS -delete

echo "[$(date)] Backup abgeschlossen: workspace-$DATE.tar.gz"
# Cron-Job fur tagliche Sicherung um 2:00 Uhr morgens einrichten
echo "0 2 * * * /opt/scripts/backup-openclaw.sh >> /var/log/openclaw-backup.log 2>&1" \
| sudo crontab -u openclaw -

Fazit

Die Umschaltung des OpenClaw Gateway von Local auf Remote ist im Kern ein Paradigmenwechsel von einem „personlichen Werkzeug" zu einer „Infrastruktur". Im Local-Modus ist das Gateway ein leiser Hintergrunddienst auf Ihrem Laptop; im Remote-Modus wird es zu einem Netzwerkdienst, der ernst genommen werden muss -- mit Authentifizierung, Verschlusselung, Monitoring, Backup und Disaster-Recovery-Plan.

Die in diesem Artikel behandelten Deployment-Pfade lassen sich in drei fortschreitende Phasen zusammenfassen:

Welche Phase fur Sie die richtige ist, hangt von Ihren spezifischen Anforderungen ab. Fur einen persoenlichen Entwicklungsassistenten ist die Tailscale-Losung moglicherweise bereits optimal; fur eine Agentenplattform, die Unternehmenskunden bedient, wird der vollstandige Stack aus Docker + Reverse-Proxy + Monitoring benotigt.[6]

Mit der fortlaufenden Entwicklung der OpenClaw-Community[2] entwickelt sich auch die Gateway-Funktionalitat rasch weiter. Es empfiehlt sich, die offizielle Dokumentation zu neuen Features wie Cluster-Koordination, Multi-Gateway-Synchronisation und Zero-Trust-Sicherheitsmodellen aufmerksam zu verfolgen -- diese werden den entscheidenden Pfad bestimmen, auf dem OpenClaw von einem persoenlichen Produktivitatswerkzeug zu einer unternehmensfahigen AI-Agentenplattform wird.[1]