OpenClaw su Hetzner (Docker, guida VPS di produzione)

Obiettivo

Eseguire un Gateway OpenClaw persistente su un VPS Hetzner con Docker, stato durevole, binari incorporati e comportamento sicuro al riavvio.

Se vuoi “OpenClaw 24/7 per ~$5”, questo e il setup piu semplice e affidabile. I prezzi Hetzner cambiano; scegli il VPS Debian/Ubuntu piu piccolo e scala verso l’alto se riscontri OOM.

Promemoria sul modello di sicurezza:

Gli agent condivisi in azienda vanno bene quando tutti sono nello stesso perimetro di fiducia e il runtime e solo per uso lavorativo.
Mantieni una separazione rigorosa: VPS/runtime dedicato + account dedicati; niente profili personali Apple/Google/browser/password manager su quell’host.
Se gli utenti sono potenzialmente avversari tra loro, separa per gateway/host/utente OS.

Vedi Sicurezza e Hosting VPS.

Cosa stiamo facendo (in termini semplici)?

Noleggiare un piccolo server Linux (VPS Hetzner)
Installare Docker (runtime isolato per le app)
Avviare il Gateway OpenClaw in Docker
Persistere ~/.openclaw + ~/.openclaw/workspace sull’host (sopravvive a riavvii/rebuild)
Accedere alla Control UI dal portatile tramite tunnel SSH

Il Gateway e accessibile tramite:

Port forwarding SSH dal portatile
Esposizione diretta della porta se gestisci firewall e token autonomamente

Questa guida presuppone Ubuntu o Debian su Hetzner. Se usi un altro VPS Linux, adatta i pacchetti di conseguenza. Per il flusso Docker generico, vedi Docker.

Percorso rapido (operatori esperti)

Provisioning del VPS Hetzner
Installa Docker
Clona il repository OpenClaw
Crea le directory host persistenti
Configura .env e docker-compose.yml
Incorpora i binari necessari nell’immagine
docker compose up -d
Verifica persistenza e accesso al Gateway

Cosa ti serve

VPS Hetzner con accesso root
Accesso SSH dal portatile
Dimestichezza con SSH + copia/incolla
~20 minuti
Docker e Docker Compose
Credenziali di autenticazione del modello
Credenziali provider opzionali
- QR WhatsApp
- Token bot Telegram
- OAuth Gmail

1) Provisioning del VPS

Crea un VPS Ubuntu o Debian su Hetzner.

Connettiti come root:

ssh root@YOUR_VPS_IP

Questa guida presuppone che il VPS sia stateful. Non trattarlo come infrastruttura usa e getta.

2) Installa Docker (sul VPS)

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

Verifica:

docker --version
docker compose version

3) Clona il repository OpenClaw

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

Questa guida presuppone che compilerai un’immagine personalizzata per garantire la persistenza dei binari.

4) Crea le directory host persistenti

I container Docker sono effimeri. Tutto lo stato a lunga durata deve risiedere sull’host.

mkdir -p /root/.openclaw/workspace

# Imposta la proprieta all'utente del container (uid 1000):
chown -R 1000:1000 /root/.openclaw

5) Configura le variabili d’ambiente

Crea .env nella root del repository.

OPENCLAW_IMAGE=openclaw:latest
OPENCLAW_GATEWAY_TOKEN=change-me-now
OPENCLAW_GATEWAY_BIND=lan
OPENCLAW_GATEWAY_PORT=18789

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

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

Genera segreti robusti:

openssl rand -hex 32

Non committare questo file.

6) Configurazione Docker Compose

Crea o aggiorna 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:
      # Consigliato: mantieni il Gateway solo in loopback sul VPS; accedi tramite tunnel SSH.
      # Per esporlo pubblicamente, rimuovi il prefisso `127.0.0.1:` e configura il firewall di conseguenza.
      - "127.0.0.1:${OPENCLAW_GATEWAY_PORT}:18789"
    command:
      [
        "node",
        "dist/index.js",
        "gateway",
        "--bind",
        "${OPENCLAW_GATEWAY_BIND}",
        "--port",
        "${OPENCLAW_GATEWAY_PORT}",
        "--allow-unconfigured",
      ]

--allow-unconfigured serve solo per comodita di bootstrap e non sostituisce una configurazione gateway corretta. Imposta comunque l’autenticazione (gateway.auth.token o password) e usa impostazioni di binding sicure per il tuo deploy.

7) Passaggi comuni del runtime Docker su VM

Usa la guida del runtime condiviso per il flusso Docker host comune:

8) Accesso specifico per Hetzner

Dopo i passaggi condivisi di build e avvio, crea il tunnel dal portatile:

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

Apri:

http://127.0.0.1:18789/

Incolla il token del gateway.

La mappa della persistenza condivisa si trova in Runtime Docker su VM.

Infrastructure as Code (Terraform)

Per i team che preferiscono flussi di lavoro infrastructure-as-code, un setup Terraform mantenuto dalla community offre:

Configurazione Terraform modulare con gestione remota dello stato
Provisioning automatizzato tramite cloud-init
Script di deploy (bootstrap, deploy, backup/ripristino)
Hardening di sicurezza (firewall, UFW, accesso solo SSH)
Configurazione del tunnel SSH per l’accesso al gateway

Repository:

Infrastruttura: openclaw-terraform-hetzner
Configurazione Docker: openclaw-docker-config

Questo approccio integra il setup Docker sopra descritto con deploy riproducibili, infrastruttura versionata e disaster recovery automatizzato.

Nota: Mantenuto dalla community. Per problemi o contributi, vedi i link ai repository qui sopra.