OpenClaw mit Docker installieren: Schritt-für-Schritt Anleitung

Warum Docker für OpenClaw?

Kurze Antwort: Weil es dir das Leben leichter macht. Docker verpackt OpenClaw mit allen Abhängigkeiten in einen Container, der auf jedem System gleich läuft — egal ob Ubuntu, Debian, CentOS oder dein Heimserver.

Wenn du OpenClaw direkt installierst (ohne Docker), brauchst du die richtige Node.js-Version, musst npm-Pakete kompilieren, Umgebungsvariablen setzen und hoffen, dass nichts mit deinem System kollidiert. Funktioniert? Meistens. Ist es elegant? Nein.

Docker löst das Problem radikal: Du sagst „starte diesen Container" und alles läuft. Kein „works on my machine" mehr. Und wenn etwas schiefgeht, löschst du den Container und fängst in 30 Sekunden neu an — deine Daten bleiben erhalten.

Die 6 Vorteile von Docker für OpenClaw

• Keine Abhängigkeitsprobleme: Node.js, npm, Build-Tools — alles ist im Container. Du installierst nur Docker, sonst nichts.
• Identische Umgebung überall: Ob lokaler Test auf deinem Laptop oder Produktiv-Server bei Hetzner — der Container ist derselbe.
• Einfache Updates: Neues Image ziehen, Container neustarten, fertig. Kein npm install, kein Build-Prozess, keine Überraschungen.
• Isolation: OpenClaw läuft in seiner eigenen Umgebung und kann dein Host-System nicht versehentlich beschädigen.
• Multi-Instanz fähig: Du willst drei OpenClaw-Instanzen für verschiedene Projekte? Mit Docker kein Problem — jede auf einem eigenen Port.
• Rollback: Update ging schief? Starte einfach das vorherige Image. Ein Befehl, 10 Sekunden, alles wie vorher.

Voraussetzungen: Was du brauchst

Die gute Nachricht: Die Liste ist kurz. Docker abstrahiert fast alles — du brauchst nur einen Server und 10 Minuten Zeit.

Hardware-Anforderungen

Für reine API-Nutzung (Claude, GPT-4o) reichen selbst günstige VPS mit 1 GB RAM. OpenClaw selbst ist schlank — die Rechenarbeit erledigt der LLM-Anbieter in der Cloud. Wenn du zusätzlich Ollama für lokale Modelle nutzen willst, brauchst du deutlich mehr Power (mindestens 8 GB RAM, besser 16 GB).

Software-Anforderungen

• Docker Engine 24+ (oder Docker Desktop auf Mac/Windows)
• Docker Compose V2 (ist in aktuellen Docker-Versionen enthalten)
• Ein API-Key von mindestens einem LLM-Anbieter (Anthropic, OpenAI oder Google)
• Optional: Eigene Domain + DNS-Zugang (für HTTPS)

Docker installieren (alle Systeme)

Falls Docker noch nicht auf deinem System läuft, hier die schnellsten Wege für jedes Betriebssystem.

Linux (Ubuntu/Debian) — empfohlen für Server

# Docker GPG-Key und Repository hinzufügen
curl -fsSL https://get.docker.com | sh

# Deinen User zur Docker-Gruppe hinzufügen (kein sudo mehr nötig)
sudo usermod -aG docker $USER

# Neu einloggen oder:
newgrp docker

# Testen
docker --version
docker compose version

macOS

# Option 1: Homebrew (empfohlen)
brew install --cask docker

# Docker Desktop starten (einmalig)
open /Applications/Docker.app

# Option 2: Download von docker.com
# https://docs.docker.com/desktop/install/mac-install/

Windows

Lade Docker Desktop für Windows herunter und installiere es. Stelle sicher, dass WSL2 als Backend aktiviert ist — Docker fragt dich während der Installation danach. Nach der Installation startest du Docker Desktop und kannst im Terminal (PowerShell oder WSL2) loslegen.

docker-compose.yml erstellen und verstehen

Die docker-compose.yml ist das Herzstück deines Setups. Eine einzige Datei, die beschreibt, wie OpenClaw als Container laufen soll — Ports, Volumes, Umgebungsvariablen, alles drin.

Die komplette docker-compose.yml

Erstelle einen Ordner für dein OpenClaw-Setup und lege die Datei an:

# Ordner erstellen
mkdir -p ~/openclaw-docker && cd ~/openclaw-docker

# docker-compose.yml erstellen
cat > docker-compose.yml << 'EOF'
services:
  openclaw:
    image: ghcr.io/openclaw/openclaw:latest
    container_name: openclaw
    restart: unless-stopped
    ports:
      - "3000:3000"
    volumes:
      - ./workspace:/home/openclaw/.openclaw/workspace
      - ./config:/home/openclaw/.openclaw/config
    env_file:
      - .env
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 15s
EOF

Zeile für Zeile erklärt

• image: ghcr.io/openclaw/openclaw:latest — Das offizielle OpenClaw Docker-Image von GitHub Container Registry. latest zieht immer die neueste stabile Version.
• container_name: openclaw — Ein lesbarer Name statt einer kryptischen Container-ID. Macht Logs und Debugging einfacher.
• restart: unless-stopped — Der Container startet automatisch neu: nach Abstürzen, nach Server-Reboots, bei Out-of-Memory. Nur wenn du ihn manuell stoppst, bleibt er aus.
• ports: "3000:3000" — Mappt Port 3000 vom Container auf Port 3000 deines Hosts. Du erreichst OpenClaw dann unter http://dein-server:3000. Willst du einen anderen Port? Ändere die linke Zahl, z.B. "8080:3000".
• volumes — Das Wichtigste: Hier werden deine Daten auf dem Host-System gespeichert, nicht im Container. Wenn du den Container löschst, bleiben Workspace und Config erhalten.
• env_file: .env — Umgebungsvariablen (API-Keys, Konfiguration) kommen aus einer separaten .env-Datei. Niemals API-Keys direkt in die docker-compose.yml schreiben!
• healthcheck — Docker prüft alle 30 Sekunden, ob OpenClaw noch lebt. Wenn 3 Checks hintereinander fehlschlagen, wird der Container als „unhealthy" markiert und kann automatisch neugestartet werden.

Umgebungsvariablen konfigurieren

Die .env-Datei enthält alles, was OpenClaw zum Starten braucht: API-Keys, Channel-Konfiguration und optionale Einstellungen.

Minimale .env-Datei

# ~/openclaw-docker/.env

# === LLM API Keys (mindestens einen) ===
ANTHROPIC_API_KEY=sk-ant-...
# OPENAI_API_KEY=sk-...
# GOOGLE_AI_API_KEY=AI...

# === OpenClaw Konfiguration ===
OPENCLAW_MODEL=anthropic/claude-sonnet-4-20250514
OPENCLAW_TIMEZONE=Europe/Berlin

# === Channel (mindestens einen) ===
# Telegram
# TELEGRAM_BOT_TOKEN=123456:ABC-DEF...

# WhatsApp (wird über QR-Code eingerichtet)
# OPENCLAW_WHATSAPP=true

# Discord
# DISCORD_BOT_TOKEN=MTI...

Alle wichtigen Variablen erklärt

• ANTHROPIC_API_KEY — Dein API-Key von console.anthropic.com. Claude ist das empfohlene Standardmodell für OpenClaw.
• OPENAI_API_KEY — Alternativ oder zusätzlich: API-Key von platform.openai.com für GPT-4o und andere OpenAI-Modelle.
• OPENCLAW_MODEL — Das Standard-LLM für alle Anfragen. Gute Optionen: anthropic/claude-sonnet-4-20250514 (bestes Preis-Leistungs-Verhältnis), openai/gpt-4o oder ollama/llama3 (kostenlos, lokal).
• OPENCLAW_TIMEZONE — Deine Zeitzone für Cron-Jobs und Zeitangaben. Format: Europe/Berlin, Europe/Vienna oder Europe/Zurich.

Erster Start: Container hochfahren

Alles vorbereitet? Dann starten wir. Drei Befehle, 60 Sekunden, OpenClaw läuft.

Schritt 1: Verzeichnisstruktur prüfen

# Dein Setup-Ordner sollte so aussehen:
~/openclaw-docker/
├── docker-compose.yml
├── .env
├── workspace/        # wird automatisch erstellt
└── config/           # wird automatisch erstellt

# Prüfen:
ls -la ~/openclaw-docker/

Schritt 2: Container starten

cd ~/openclaw-docker

# Container im Hintergrund starten (-d = detached)
docker compose up -d

# Logs ansehen (Ctrl+C zum Beenden)
docker compose logs -f

Schritt 3: Prüfen ob alles läuft

# Container-Status prüfen
docker compose ps

# Erwartete Ausgabe:
# NAME       IMAGE                              STATUS          PORTS
# openclaw   ghcr.io/openclaw/openclaw:latest   Up 2 minutes    0.0.0.0:3000->3000/tcp

# Health-Check prüfen
docker inspect openclaw --format='{{.State.Health.Status}}'
# → "healthy"

Wenn du healthy siehst, läuft OpenClaw. Du erreichst das Gateway unter http://localhost:3000 (lokal) oder http://deine-server-ip:3000 (remote). Je nachdem, welchen Channel du konfiguriert hast (Telegram, WhatsApp, Discord), kannst du jetzt mit deinem Assistenten chatten.

Reverse Proxy und HTTPS einrichten

Für den Produktiv-Einsatz willst du HTTPS und eine eigene Domain. Ein Reverse Proxy wie Nginx macht das in wenigen Minuten möglich.

Warum ein Reverse Proxy?

Ohne Reverse Proxy erreichst du OpenClaw nur über http://ip:3000 — unverschlüsselt, mit Portnummer, nicht besonders professionell. Ein Reverse Proxy gibt dir:

• HTTPS: Verschlüsselte Verbindung (Pflicht für WhatsApp-Webhooks)
• Eigene Domain: https://mein-assistent.de statt http://123.456.789.0:3000
• Sicherheit: Port 3000 bleibt intern, nur 80/443 sind öffentlich
• Load Balancing: Für mehrere Instanzen (fortgeschritten)

Nginx + Let's Encrypt Setup

Wir erweitern die docker-compose.yml um Nginx und Certbot für automatische SSL-Zertifikate:

# Erweiterte docker-compose.yml mit Nginx
services:
  openclaw:
    image: ghcr.io/openclaw/openclaw:latest
    container_name: openclaw
    restart: unless-stopped
    # Kein "ports" mehr — Nginx übernimmt
    expose:
      - "3000"
    volumes:
      - ./workspace:/home/openclaw/.openclaw/workspace
      - ./config:/home/openclaw/.openclaw/config
    env_file:
      - .env
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  nginx:
    image: nginx:alpine
    container_name: nginx
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/conf.d:/etc/nginx/conf.d
      - ./certbot/www:/var/www/certbot
      - ./certbot/conf:/etc/letsencrypt
    depends_on:
      - openclaw

  certbot:
    image: certbot/certbot
    volumes:
      - ./certbot/www:/var/www/certbot
      - ./certbot/conf:/etc/letsencrypt

Nginx-Konfiguration

# ./nginx/conf.d/openclaw.conf
mkdir -p nginx/conf.d

cat > nginx/conf.d/openclaw.conf << 'EOF'
server {
    listen 80;
    server_name dein-assistent.de;

    location /.well-known/acme-challenge/ {
        root /var/www/certbot;
    }

    location / {
        return 301 https://$host$request_uri;
    }
}

server {
    listen 443 ssl;
    server_name dein-assistent.de;

    ssl_certificate /etc/letsencrypt/live/dein-assistent.de/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/dein-assistent.de/privkey.pem;

    location / {
        proxy_pass http://openclaw:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # WebSocket-Support
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}
EOF

SSL-Zertifikat erstellen

# Zertifikat anfordern (einmalig)
docker compose run --rm certbot certonly \
  --webroot -w /var/www/certbot \
  -d dein-assistent.de \
  --email deine@email.de \
  --agree-tos --no-eff-email

# Nginx neustarten, um Zertifikat zu laden
docker compose restart nginx

# Automatische Erneuerung (alle 12 Stunden prüfen)
echo "0 */12 * * * cd ~/openclaw-docker && docker compose run --rm certbot renew && docker compose restart nginx" | crontab -

Ersetze dein-assistent.de durch deine Domain und stelle sicher, dass der DNS-A-Record auf deine Server-IP zeigt. Nach dem Setup erreichst du OpenClaw unter https://dein-assistent.de — verschlüsselt und professionell.

Updates: Container aktualisieren

OpenClaw-Updates mit Docker sind schmerzlos. Drei Befehle, eine Minute Downtime.

Manuelles Update

cd ~/openclaw-docker

# 1. Neues Image herunterladen
docker compose pull

# 2. Container mit neuem Image neustarten
docker compose up -d

# 3. Alte, ungenutzte Images aufräumen (optional)
docker image prune -f

Das war's. Docker erkennt, dass ein neues Image verfügbar ist, stoppt den alten Container und startet einen neuen mit der aktualisierten Version. Deine Volumes (Workspace, Config) bleiben unberührt.

Automatische Updates mit Watchtower

Willst du dich nicht um Updates kümmern? Watchtower prüft regelmäßig, ob neue Images verfügbar sind, und aktualisiert Container automatisch:

# Watchtower zur docker-compose.yml hinzufügen:
  watchtower:
    image: containrrr/watchtower
    container_name: watchtower
    restart: unless-stopped
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      - WATCHTOWER_CLEANUP=true
      - WATCHTOWER_POLL_INTERVAL=86400   # Alle 24 Stunden prüfen
      - WATCHTOWER_INCLUDE_STOPPED=false
    command: openclaw   # Nur den OpenClaw-Container updaten

Rollback bei Problemen

# Welche Images sind lokal verfügbar?
docker images ghcr.io/openclaw/openclaw

# Auf eine bestimmte Version zurückrollen:
# 1. In docker-compose.yml das Tag ändern:
#    image: ghcr.io/openclaw/openclaw:1.5.1
# 2. Container neustarten
docker compose up -d

Backup und Datenmanagement

Docker macht Backups einfach: Alles, was du sichern musst, liegt in den Volume-Ordnern auf deinem Host-System.

Was muss gesichert werden?

• ./workspace/ — Dein Workspace: MEMORY.md, SOUL.md, Skills, Memory-Dateien
• ./config/ — OpenClaw-Konfiguration
• .env — Deine API-Keys und Einstellungen
• docker-compose.yml — Dein Container-Setup

Einfaches Backup-Script

#!/bin/bash
# backup-openclaw.sh

BACKUP_DIR="/home/user/backups/openclaw"
SOURCE_DIR="/home/user/openclaw-docker"
DATE=$(date +%Y-%m-%d_%H%M)

mkdir -p "$BACKUP_DIR"

# Backup erstellen (ohne Docker-Images)
tar -czf "$BACKUP_DIR/openclaw-$DATE.tar.gz" \
  -C "$SOURCE_DIR" \
  workspace/ config/ .env docker-compose.yml

# Alte Backups löschen (älter als 30 Tage)
find "$BACKUP_DIR" -name "openclaw-*.tar.gz" -mtime +30 -delete

echo "Backup erstellt: openclaw-$DATE.tar.gz"

# Script ausführbar machen
chmod +x backup-openclaw.sh

# Automatisches Backup per Cron (täglich um 3 Uhr)
echo "0 3 * * * /home/user/backup-openclaw.sh" | crontab -

Restore aus Backup

# Container stoppen
cd ~/openclaw-docker && docker compose down

# Backup entpacken (überschreibt aktuelle Daten)
tar -xzf ~/backups/openclaw/openclaw-2026-03-19_0300.tar.gz -C ~/openclaw-docker/

# Container wieder starten
docker compose up -d

Multi-Container Setup: OpenClaw + Ollama

Die volle Power: OpenClaw für die Orchestrierung, Ollama für lokale LLM-Modelle — alles in Docker, komplett ohne Cloud-Abhängigkeit.

Dieses Setup ist ideal für maximale Datenschutz-Anforderungen: Keine Daten verlassen dein Netzwerk, weil das LLM lokal läuft.

# docker-compose.yml mit Ollama
services:
  openclaw:
    image: ghcr.io/openclaw/openclaw:latest
    container_name: openclaw
    restart: unless-stopped
    ports:
      - "3000:3000"
    volumes:
      - ./workspace:/home/openclaw/.openclaw/workspace
      - ./config:/home/openclaw/.openclaw/config
    env_file:
      - .env
    depends_on:
      - ollama
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    restart: unless-stopped
    ports:
      - "11434:11434"
    volumes:
      - ollama_data:/root/.ollama
    # Für GPU-Support (NVIDIA):
    # deploy:
    #   resources:
    #     reservations:
    #       devices:
    #         - driver: nvidia
    #           count: 1
    #           capabilities: [gpu]

volumes:
  ollama_data:

Ollama-Modell herunterladen und konfigurieren

# Container starten
docker compose up -d

# Modell herunterladen (im laufenden Container)
docker exec -it ollama ollama pull llama3.1:8b

# In der .env anpassen:
# OPENCLAW_MODEL=ollama/llama3.1:8b
# OLLAMA_HOST=http://ollama:11434

Beachte: Lokale Modelle brauchen deutlich mehr Ressourcen als API-Calls. Llama 3.1 8B läuft flüssig auf Systemen mit 16 GB RAM. Für kleinere Setups empfehlen wir günstige API-Modelle als primäre Option und Ollama als Fallback für sensible Anfragen.

Troubleshooting: Die häufigsten Probleme

Docker-Setups laufen meistens reibungslos — aber wenn etwas klemmt, sind es fast immer dieselben 5 Probleme.

Problem 1: „Port already in use"

# Fehler: Bind for 0.0.0.0:3000 failed: port is already allocated

# Lösung 1: Anderen Port nutzen
# In docker-compose.yml: "3001:3000" statt "3000:3000"

# Lösung 2: Prüfen, was den Port belegt
sudo lsof -i :3000
# → Prozess beenden oder anderen Port wählen

Problem 2: „Permission denied" bei Volumes

# Fehler: EACCES: permission denied, open '/home/openclaw/.openclaw/...'

# Ursache: Der Container-User hat keine Schreibrechte auf die Host-Ordner

# Lösung: Berechtigungen setzen
sudo chown -R 1000:1000 ./workspace ./config

# Oder (weniger sicher, aber funktioniert):
chmod -R 777 ./workspace ./config

Problem 3: Container startet und stoppt sofort

# Logs prüfen — die Antwort steht fast immer hier:
docker compose logs openclaw

# Häufige Ursachen:
# - .env-Datei fehlt oder ist leer
# - Ungültiger API-Key (Format-Fehler)
# - Syntaxfehler in der .env (keine Leerzeichen um "=")

# Richtig:   ANTHROPIC_API_KEY=sk-ant-abc123
# Falsch:    ANTHROPIC_API_KEY = sk-ant-abc123

Problem 4: „Cannot connect to Docker daemon"

# Docker-Service läuft nicht

# Linux:
sudo systemctl start docker
sudo systemctl enable docker   # Autostart bei Boot

# Mac/Windows: Docker Desktop starten

# Prüfen:
docker info

Problem 5: Container ist „unhealthy"

# Health-Check-Details ansehen:
docker inspect openclaw --format='{{json .State.Health}}' | jq

# Häufige Ursachen:
# - OpenClaw braucht noch Zeit zum Starten (start_period abwarten)
# - API-Key ungültig → OpenClaw startet, kann aber nicht arbeiten
# - Nicht genug RAM → Container wird vom OS gekillt

# RAM-Verbrauch prüfen:
docker stats openclaw --no-stream

Docker vs. direkte Installation: Vergleich

Docker ist nicht immer die beste Wahl. Hier ein ehrlicher Vergleich, damit du die richtige Entscheidung für dein Setup triffst.

Unsere Empfehlung

• Docker wählen, wenn du: einen Server (VPS, NAS, Heimserver) betreibst, mehrere Instanzen willst, saubere Updates schätzt oder einfach ein „es funktioniert immer"-Setup willst.
• Direkte Installation wählen, wenn du: OpenClaw auf deinem Hauptrechner (Laptop/Desktop) betreibst, nur eine Instanz brauchst oder maximale Kontrolle über jeden Aspekt willst.
• Für Einsteiger: Docker. Die Abstraktion schützt dich vor den häufigsten Anfängerfehlern und macht Updates schmerzlos.

Häufige Fragen (FAQ)

Fazit: Docker ist der beste Weg für Self-Hosted OpenClaw

Docker nimmt dir bei der OpenClaw-Installation die größten Schmerzpunkte ab: Abhängigkeiten, Updates, Isolation und Backups. Ob du einen günstigen VPS für 5€/Monat bei Hetzner betreibst, eine Synology NAS im Keller stehen hast oder mehrere Instanzen für verschiedene Projekte brauchst — mit Docker bist du in 10 Minuten startklar.

Die drei Befehle, die du dir merken musst: docker compose up -d (starten), docker compose pull && docker compose up -d (updaten) und docker compose logs -f (debuggen). Alles andere steht in der docker-compose.yml — und die hast du nach diesem Guide fertig auf der Platte.

Weiterführende Artikel

• OpenClaw einrichten: Der komplette Guide — Konfiguration nach der Installation
• OpenClaw Sicherheit — Best Practices für Self-Hosted Setups
• OpenClaw vs. Ollama & GPT4All — Lokale Modelle im Vergleich
• OpenClaw Kosten — Was API-Nutzung wirklich kostet
• OpenClaw auf Telegram einrichten — Einen Channel konfigurieren