OpenClaw sur VPS : Installation complète

Faire tourner OpenClaw sur votre machine locale convient pour le développement, mais la production exige un serveur disponible 24h/24. Un VPS Ubuntu est la solution la plus courante : coût maîtrisé, contrôle total, aucune dépendance à un cloud propriétaire. Ce tutoriel vous guide de la configuration initiale du serveur jusqu'au déploiement d'un agent SEO autonome en production, avec systemd pour la supervision, un utilisateur dédié pour la sécurité et un firewall correctement configuré. Assurez-vous d'avoir lu Installer OpenClaw avant de commencer ce guide.

---

Choisir son VPS

Avant de déployer, il faut sélectionner un VPS adapté aux besoins d'un agent OpenClaw en production.

Spécifications recommandées

Un agent OpenClaw standard (quelques tasks par heure, mémoire SQLite) fonctionne correctement avec :

• CPU : 2 vCPU minimum
• RAM : 2 Go minimum (4 Go recommandés si vous utilisez Ollama ou plusieurs agents)
• Stockage : 20 Go SSD minimum
• OS : Ubuntu 22.04 LTS (support jusqu'en 2027) ou Ubuntu 24.04 LTS

Fournisseurs courants

Fournisseur	Offre d'entrée	Points forts
Hetzner Cloud	~4€/mois (CX22)	Excellent rapport qualité/prix, datacenter EU
OVHcloud	~3,50€/mois (Starter)	Présence FR, conformité RGPD facilitée
DigitalOcean	~6$/mois (Basic)	Interface simple, bonne documentation
Scaleway	~4€/mois (DEV1-S)	Datacenter Paris, conformité EU

Pour un agent de veille ou SEO, un VPS Hetzner CX22 (2 vCPU, 4 Go RAM) à ~6€/mois est largement suffisant.

Préparer l'accès SSH

Générez une paire de clés SSH sur votre machine locale avant de créer le VPS :

ssh-keygen -t ed25519 -C "openclaw-vps" -f ~/.ssh/openclaw_vps
# Entrez une passphrase forte

Ajoutez la clé publique lors de la création du VPS chez votre fournisseur.

---

Préparer le serveur Ubuntu

Connectez-vous à votre VPS en tant que root :

ssh root@VOTRE_IP_VPS -i ~/.ssh/openclaw_vps

Mise à jour initiale

apt update && apt upgrade -y
apt install -y curl git wget unzip software-properties-common ufw fail2ban

Configurer le fuseau horaire

timedatectl set-timezone Europe/Paris
timedatectl status

Créer un utilisateur dédié

Ne faites jamais tourner vos agents en tant que root. Créez un utilisateur spécifique :

useradd -m -s /bin/bash -G sudo openclaw
passwd openclaw  # Définissez un mot de passe fort

# Copier les clés SSH pour le nouvel utilisateur
mkdir -p /home/openclaw/.ssh
cp /root/.authorized_keys /home/openclaw/.ssh/authorized_keys 2>/dev/null || \
  cp ~/.ssh/authorized_keys /home/openclaw/.ssh/authorized_keys
chown -R openclaw:openclaw /home/openclaw/.ssh
chmod 700 /home/openclaw/.ssh
chmod 600 /home/openclaw/.ssh/authorized_keys

Configurer le firewall UFW

# Réinitialiser UFW
ufw --force reset

# Politique par défaut : bloquer tout entrant, autoriser tout sortant
ufw default deny incoming
ufw default allow outgoing

# Autoriser SSH (indispensable avant d'activer UFW)
ufw allow 22/tcp comment "SSH"

# Activer UFW
ufw --force enable

# Vérifier l'état
ufw status verbose

Important : activez UFW uniquement après avoir autorisé le port SSH. Sinon, vous risquez de perdre l'accès à votre serveur.

Configurer fail2ban

fail2ban protège contre les attaques par force brute sur SSH :

systemctl enable fail2ban
systemctl start fail2ban

# Vérifier les banissements actifs
fail2ban-client status sshd

---

Installer OpenClaw sur le VPS

Connectez-vous maintenant avec l'utilisateur dédié :

ssh openclaw@VOTRE_IP_VPS -i ~/.ssh/openclaw_vps

Installer Python 3.11

Ubuntu 22.04 inclut Python 3.10. Pour Python 3.11 (recommandé) :

sudo add-apt-repository ppa:deadsnakes/ppa -y
sudo apt update
sudo apt install -y python3.11 python3.11-venv python3.11-dev
python3.11 --version
# Python 3.11.x

Créer l'arborescence du projet

mkdir -p /home/openclaw/agents/veille-seo
cd /home/openclaw/agents/veille-seo

# Créer l'environnement virtuel
python3.11 -m venv .venv
source .venv/bin/activate

# Mettre à jour pip
pip install --upgrade pip

# Installer OpenClaw
pip install "openclaw[all]"

# Vérifier
openclaw --version

Créer le fichier de configuration

# Initialiser la configuration
openclaw init

# Créer les répertoires nécessaires
mkdir -p outputs logs

Éditez openclaw.yaml avec nano :

nano openclaw.yaml

Configuration pour production :

# openclaw.yaml (production VPS)
agent:
  name: "veille_seo_agent"
  description: "Agent de veille SEO et génération de briefs"
  reasoning_mode: "plan_execute"
  max_iterations: 20
  timeout_seconds: 180

llm:
  provider: "openai"
  model: "gpt-4o-mini"
  temperature: 0.15
  max_tokens: 8192

memory:
  enabled: true
  backend: "sqlite"
  db_path: "/home/openclaw/agents/veille-seo/memory.db"
  episodic_retention_days: 90

skills:
  - name: "web_search"
    enabled: true
    config:
      provider: "duckduckgo"
      max_results: 10

  - name: "write_file"
    enabled: true
    config:
      base_dir: "/home/openclaw/agents/veille-seo/outputs"
      allowed_extensions: [".txt", ".md", ".json", ".csv"]

  - name: "http_request"
    enabled: true
    config:
      timeout_seconds: 30

  - name: "send_email"
    enabled: true
    config:
      provider: "sendgrid"
      from_address: "agent@votredomaine.com"

logging:
  level: "INFO"
  format: "json"
  output: "/home/openclaw/agents/veille-seo/logs/agent.jsonl"

env_file: "/home/openclaw/agents/veille-seo/.env"

Créer le fichier .env

nano /home/openclaw/agents/veille-seo/.env

# .env
OPENAI_API_KEY=sk-proj-votre-clé
SENDGRID_API_KEY=SG.votre-clé-sendgrid

Sécurisez les permissions du fichier .env :

chmod 600 /home/openclaw/agents/veille-seo/.env

Créer le script principal

nano /home/openclaw/agents/veille-seo/run_agent.py

#!/usr/bin/env python3
# run_agent.py
import sys
import logging
from pathlib import Path
from openclaw import Agent
from openclaw.config import load_config

# Répertoire du projet
BASE_DIR = Path(__file__).parent

def main():
    config = load_config(BASE_DIR / "openclaw.yaml")
    agent = Agent(config)

    task = """
    Effectue une veille SEO complète :
    1. Recherche les 5 dernières actualités sur "agents IA" et "LLM"
    2. Pour chaque actualité, extrais : titre, source, résumé en 3 phrases, pertinence SEO
    3. Identifie 3 mots-clés émergents dans ces articles
    4. Enregistre un rapport structuré dans outputs/veille_{date}.md
    5. Si configured, envoie le rapport par email à admin@votredomaine.com
    """

    logging.info("Démarrage de l'agent de veille SEO")
    result = agent.run(task=task)

    if result.success:
        logging.info(f"Agent terminé. Iterations: {result.iterations}, Duration: {result.duration_seconds:.1f}s")
        sys.exit(0)
    else:
        logging.error(f"Agent échoué: {result.error}")
        sys.exit(1)

if __name__ == "__main__":
    main()

chmod +x /home/openclaw/agents/veille-seo/run_agent.py

Tester manuellement

source /home/openclaw/agents/veille-seo/.venv/bin/activate
cd /home/openclaw/agents/veille-seo
python3 run_agent.py

Vérifiez que le fichier de sortie est créé dans outputs/.

---

Configurer systemd

systemd permet de gérer l'agent comme un service système : démarrage automatique, redémarrage en cas d'erreur, logs centralisés.

Créer le fichier de service

sudo nano /etc/systemd/system/openclaw-veille-seo.service

[Unit]
Description=OpenClaw Agent - Veille SEO
After=network-online.target
Wants=network-online.target
# Redémarrer si le réseau est coupé puis rétabli
PartOf=network-online.target

[Service]
Type=oneshot
User=openclaw
Group=openclaw
WorkingDirectory=/home/openclaw/agents/veille-seo
ExecStart=/home/openclaw/agents/veille-seo/.venv/bin/python3 /home/openclaw/agents/veille-seo/run_agent.py
EnvironmentFile=/home/openclaw/agents/veille-seo/.env
StandardOutput=journal
StandardError=journal
SyslogIdentifier=openclaw-veille-seo

# Limites de ressources
MemoryLimit=512M
CPUQuota=80%

# Sécurité
NoNewPrivileges=true
ProtectSystem=strict
ProtectHome=read-only
ReadWritePaths=/home/openclaw/agents/veille-seo/outputs
ReadWritePaths=/home/openclaw/agents/veille-seo/logs
ReadWritePaths=/home/openclaw/agents/veille-seo/memory.db

[Install]
WantedBy=multi-user.target

Créer le timer systemd (cron)

Pour lancer l'agent automatiquement chaque jour à 7h00 :

sudo nano /etc/systemd/system/openclaw-veille-seo.timer

[Unit]
Description=Timer pour OpenClaw Agent Veille SEO
Requires=openclaw-veille-seo.service

[Timer]
OnCalendar=*-*-* 07:00:00
Persistent=true
RandomizedDelaySec=300

[Install]
WantedBy=timers.target

Persistent=true garantit que si le serveur était éteint à l'heure prévue, le job s'exécutera au prochain démarrage. RandomizedDelaySec=300 ajoute un délai aléatoire jusqu'à 5 minutes pour éviter les pics de charge si vous avez plusieurs agents.

Activer et démarrer

sudo systemctl daemon-reload
sudo systemctl enable openclaw-veille-seo.timer
sudo systemctl start openclaw-veille-seo.timer

# Vérifier l'état du timer
sudo systemctl status openclaw-veille-seo.timer
sudo systemctl list-timers | grep openclaw

Lancer manuellement (hors timer)

sudo systemctl start openclaw-veille-seo.service
sudo systemctl status openclaw-veille-seo.service

Consulter les logs

# Logs en temps réel
sudo journalctl -u openclaw-veille-seo.service -f

# Logs des 24 dernières heures
sudo journalctl -u openclaw-veille-seo.service --since "24 hours ago"

# Logs structurés (fichier JSON)
tail -f /home/openclaw/agents/veille-seo/logs/agent.jsonl | python3 -m json.tool

---

Sécuriser le déploiement

Désactiver la connexion root SSH

Une fois que vous avez vérifié que la connexion avec l'utilisateur openclaw fonctionne :

sudo nano /etc/ssh/sshd_config

Modifiez ou ajoutez ces lignes :

PermitRootLogin no
PasswordAuthentication no
PubkeyAuthentication yes
AllowUsers openclaw

sudo systemctl restart sshd

Testez la connexion dans une nouvelle fenêtre avant de fermer la session actuelle.

Rotation des logs

Configurez logrotate pour éviter que les logs ne remplissent le disque :

sudo nano /etc/logrotate.d/openclaw

/home/openclaw/agents/*/logs/*.jsonl {
    daily
    rotate 30
    compress
    delaycompress
    missingok
    notifempty
    create 640 openclaw openclaw
}

Surveiller l'utilisation des ressources

# Mémoire et CPU consommés par le service
sudo systemctl show openclaw-veille-seo.service --property=MemoryCurrent,CPUUsageNSec

# Espace disque
du -sh /home/openclaw/agents/veille-seo/
df -h /

---

Exemple concret : agent SEO autonome

Voici un exemple complet d'agent SEO qui tourne chaque jour, analyse des mots-clés cibles et génère des briefs de contenu.

Structure du projet

/home/openclaw/agents/seo-briefs/
├── .venv/
├── .env
├── openclaw.yaml
├── run_agent.py
├── keywords.txt          # Liste des mots-clés à analyser
├── outputs/
│   ├── briefs/           # Briefs générés
│   └── reports/          # Rapports de performance
└── logs/
    └── agent.jsonl

Script de génération de briefs

#!/usr/bin/env python3
# run_agent.py - Agent SEO Briefs
from pathlib import Path
from datetime import date
from openclaw import Agent
from openclaw.config import load_config

BASE_DIR = Path(__file__).parent

def main():
    # Charger les mots-clés cibles
    keywords_file = BASE_DIR / "keywords.txt"
    keywords = [k.strip() for k in keywords_file.read_text().splitlines() if k.strip()]

    # Traiter les 3 premiers mots-clés (économiser les tokens)
    batch = keywords[:3]

    config = load_config(BASE_DIR / "openclaw.yaml")
    agent = Agent(config)

    today = date.today().isoformat()

    for keyword in batch:
        task = f"""
        Génère un brief SEO complet pour le mot-clé : "{keyword}"

        Le brief doit inclure :
        1. Volume de recherche estimé et difficulté SEO (recherche web)
        2. Analyse des 3 premiers résultats Google (titres, structures, longueur)
        3. Angle différenciant recommandé
        4. Structure d'article suggérée (H1, H2, H3)
        5. 5 mots-clés secondaires à intégrer
        6. Nombre de mots recommandé

        Enregistre le brief dans outputs/briefs/brief_{keyword.replace(' ', '-')}_{today}.md
        """

        result = agent.run(task=task)
        print(f"Brief '{keyword}': {'OK' if result.success else 'ERREUR'}")

if __name__ == "__main__":
    main()

Résultat attendu

Après exécution, le dossier outputs/briefs/ contiendra des fichiers Markdown structurés, prêts à être transmis à des rédacteurs ou importés dans un CMS. L'agent aura effectué les recherches, analysé la concurrence et structuré les recommandations sans intervention humaine.

Pour aller plus loin dans l'automatisation SEO, consultez le guide Automatisation SEO avec OpenClaw.

---

Bonnes pratiques

Un agent par service systemd

Résistez à la tentation de faire tourner plusieurs agents dans un seul script. Créez un service systemd par agent. Cela facilite la supervision, l'arrêt sélectif et le debugging.

Monitorer les coûts API

Les agents en production consomment des tokens. Définissez des alertes de dépenses dans votre dashboard OpenAI ou Anthropic. Implémentez un log du nombre de tokens consommés par exécution :

result = agent.run(task=task)
print(f"Tokens consommés: {result.tokens_used}")
# Loggez cette valeur dans votre système de monitoring

Sauvegarder la base de mémoire

La mémoire épisodique SQLite est un fichier précieux. Sauvegardez-la régulièrement :

# Script de backup quotidien
sudo nano /etc/cron.daily/backup-openclaw

#!/bin/bash
DATE=$(date +%Y%m%d)
cp /home/openclaw/agents/*/memory.db /home/openclaw/backups/memory_${DATE}.db 2>/dev/null
find /home/openclaw/backups/ -name "memory_*.db" -mtime +30 -delete

sudo chmod +x /etc/cron.daily/backup-openclaw
mkdir -p /home/openclaw/backups

Tester avant de déployer

Avant de modifier la configuration d'un agent en production, testez toujours localement ou dans un environnement de staging. Un changement de reasoning_mode ou de max_iterations peut multiplier les coûts de tokens de façon inattendue.

---

Conclusion

Votre agent OpenClaw tourne maintenant en production sur un VPS Ubuntu sécurisé, supervisé par systemd et protégé par un firewall et fail2ban. L'exécution est automatique, les logs sont centralisés et les ressources sont limitées pour éviter les débordements. Cette infrastructure peut accueillir plusieurs agents indépendants avec des timers différents. Pour comprendre l'ensemble des capacités d'OpenClaw et enrichir vos agents, revenez au guide complet OpenClaw. Pour l'installation locale préalable à tout déploiement, consultez Installer OpenClaw.