OpenClaw sur VPS : Installation complète
Déployez OpenClaw sur un VPS Ubuntu : installation, configuration systemd, sécurisation et exemple d'agent SEO autonome en production.
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, puis passez par Configurer OpenClaw pour fiabiliser le openclaw.yaml avant la mise en production. Pour un panorama des options d'hébergement (PaaS, conteneur, serveur), voyez aussi Héberger OpenClaw.
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
Exposer une API : reverse proxy Nginx + HTTPS
Si votre agent expose une API HTTP (mode serveur d'OpenClaw, par exemple pour recevoir des webhooks ou des requêtes à la demande), ne l'exposez jamais directement sur Internet. Placez un reverse proxy Nginx devant lui : il gère le TLS, ajoute des en-têtes de sécurité et masque le port interne de l'agent.
Dans ce scénario, l'agent écoute en local (par exemple 127.0.0.1:8000) via un service systemd de type simple plutôt que oneshot, et Nginx fait la terminaison HTTPS sur le port 443.
Installer Nginx
sudo apt install -y nginx
Ouvrez le port HTTP/HTTPS dans UFW (le port 8000 de l'agent reste, lui, fermé à l'extérieur) :
sudo ufw allow 'Nginx Full' # ouvre 80 et 443
sudo ufw status verbose
Configurer le virtual host
sudo nano /etc/nginx/sites-available/openclaw
server {
listen 80;
server_name agent.votredomaine.com;
location / {
proxy_pass http://127.0.0.1:8000;
proxy_http_version 1.1;
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;
proxy_read_timeout 300s; # les tâches d'agent peuvent être longues
}
}
Activez le site et rechargez Nginx :
sudo ln -s /etc/nginx/sites-available/openclaw /etc/nginx/sites-enabled/
sudo nginx -t # valider la syntaxe avant de recharger
sudo systemctl reload nginx
Activer HTTPS avec Let's Encrypt
Certbot obtient et renouvelle automatiquement un certificat gratuit. Assurez-vous d'abord que l'enregistrement DNS A de agent.votredomaine.com pointe bien vers l'IP de votre VPS.
sudo apt install -y certbot python3-certbot-nginx
sudo certbot --nginx -d agent.votredomaine.com --redirect --agree-tos -m admin@votredomaine.com
Certbot modifie automatiquement le virtual host pour ajouter le bloc listen 443 ssl et la redirection HTTP vers HTTPS. Le renouvellement est planifié via un timer systemd installé par le paquet ; vérifiez-le et testez un renouvellement à blanc :
sudo systemctl list-timers | grep certbot
sudo certbot renew --dry-run
Le proxy_read_timeout élevé évite qu'une tâche d'agent qui dépasse la minute ne renvoie une erreur 504 Gateway Timeout. Pour une mise en production complète (rate limiting, en-têtes HSTS, healthchecks applicatifs), poursuivez avec OpenClaw en production.
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 /
Alerte basique en cas d'échec
Pour être prévenu sans installer de stack lourde, ajoutez OnFailure= au service systemd : à chaque exécution échouée, une unité de notification se déclenche.
# Dans [Unit] de openclaw-veille-seo.service
OnFailure=notify-failure@%n.service
sudo nano /etc/systemd/system/notify-failure@.service
[Unit]
Description=Notification d'échec pour %i
[Service]
Type=oneshot
ExecStart=/usr/bin/curl -s -X POST https://votre-webhook-slack-ou-ntfy \
-d "Échec du service %i sur $(hostname) à $(date)"
Cette approche couvre l'essentiel d'un VPS à agent unique. Pour des métriques détaillées (taux d'erreur, latence LLM, coût par exécution) et des tableaux de bord, branchez la stack décrite dans Logs et monitoring OpenClaw.
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. Si vous cherchez un cadrage plus transverse avant le passage en production, consultez aussi Déployer un agent IA.
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.
Articles liés
- Guide complet OpenClaw
- Installer OpenClaw
- Héberger OpenClaw
- OpenClaw avec Docker
- OpenClaw en production
- Logs et monitoring OpenClaw
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. Pour industrialiser la suite, enchaînez avec Configurer OpenClaw, OpenClaw avec Docker ou Déployer un agent IA selon votre cible.
Restez informé sur les agents IA
Nouveaux tutoriels, comparatifs et guides pratiques directement dans votre boîte mail.