AUTOMATISATION & IADocker · VPS

Faire tourner un agent IA sur un VPS à petit budget

25 juin 2026·17 min de lecture

Tu payes 20-50€/mois pour des outils IA qui te donnent accès à des modèles que tu ne contrôles pas. Les tarifs changent, les accès évoluent, et tes données passent par des serveurs tiers. Si tu veux un agent IA qui t'appartient vraiment, avec des coûts prévisibles et un contrôle total, la solution est de le déployer toi-même sur un VPS avec Docker.

Ce guide t'amène de zéro à un agent IA fonctionnel, accessible depuis n'importe quel appareil.

Ce que tu vas obtenir

Un VPS avec un agent IA opérationnel (Ollama + Open WebUI) que tu peux utiliser pour du chat, de la rédaction, de l'analyse de données et l'exécution de tâches. Le tout hébergé chez toi, accessible via HTTPS, avec un contrôle total sur tes données et tes coûts.

Étape 1 : Choisir et provisionner ton VPS

Le choix du VPS dépend de ton usage. Voici les recommandations :

Pour du chat léger et de la rédaction (7-8B paramètres) :

RAM : 8 Go minimum
CPU : 4 vCPU
Stockage : 50 Go SSD
Budget : 8-15€/mois
Providers recommandés : Hetzner (CX31), OVH (B2-15), DigitalOcean

Pour des modèles plus gros (13-30B paramètres) :

RAM : 16-32 Go
CPU : 8 vCPU
Stockage : 100 Go SSD
Budget : 25-50€/mois
GPU optionnel mais recommandé pour l'inference

Pour du serious business (modèles 70B+) :

RAM : 64 Go+
GPU : NVIDIA A10 ou équivalent
Budget : 100-200€/mois
Providers : Lambda Labs, RunPod, ou OVH avec GPU

Commande de déploiement sur Hetzner (exemple) :

# Via hcloud CLI ou interface web
hcloud server create --name agent-ia --type cx31 --image ubuntu-22.04 --ssh-key my-key

Connecte-toi en SSH :

ssh root@IP_DE_TON_VPS

Étape 2 : Installer Docker et Docker Compose

Sur Ubuntu 22.04, installe Docker en quelques commandes :

# Mise à jour du système
apt update && apt upgrade -y

# Installation de Docker
curl -fsSL https://get.docker.com | sh

# Ajout de ton utilisateur au groupe docker (pour ne pas utiliser sudo)
usermod -aG docker $USER

# Installation de Docker Compose (plugin)
apt install docker-compose-plugin -y

# Vérification
docker --version
docker compose version

Sécurisation immédiate :

# Installer UFW (firewall)
apt install ufw -y
ufw allow OpenSSH
ufw allow 80/tcp
ufw allow 443/tcp
ufw enable

# Activer le fail2ban pour bloquer les tentatives de brute force
apt install fail2ban -y
systemctl enable fail2ban

N'expose JAMAIS un port sans pare-feu. C'est la première erreur des débutants et la porte d'entrée des attaques.

Étape 3 : Installer Ollama pour faire tourner les modèles

Ollama est l'outil clé. Il permet de télécharger et faire tourner des modèles LLM localement avec une commande simple.

# Installation d'Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Vérification
ollama --version

Télécharge tes premiers modèles :

# Modèle léger et rapide pour le chat (4 Go de RAM requis)
ollama pull llama3.1:8b

# Modèle pour la rédaction et l'analyse (8 Go de RAM)
ollama pull llama3.1:8b-instruct-q5_K_M

# Modèle compact pour les tâches simples (2 Go de RAM)
ollama pull phi3:mini

# Vision (pour analyser des images)
ollama pull llava:7b

Teste que tout fonctionne :

ollama run llama3.1:8b "Bonjour, qui es-tu ?"

Si tu obtiens une réponse, Ollama fonctionne. Note le port par défaut : 11434. C'est l'API locale qu'Open WebUI va utiliser.

Étape 4 : Déployer Open WebUI avec Docker Compose

Open WebUI est une interface web complète qui se connecte à Ollama. C'est l'équivalent de ChatGPT mais en self-hosted.

Crée le fichier de configuration :

mkdir -p /opt/agent-ia
cd /opt/agent-ia

Crée le fichier docker-compose.yml :

version: '3.8'

services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    ports:
      - "3000:8080"
    volumes:
      - open-webui-data:/app/backend/data
    environment:
      - OLLAMA_BASE_URL=http://host.docker.internal:11434
      - WEBUI_AUTH=true
      - ENABLE_SIGNUP=false
    restart: unless-stopped
    networks:
      - ia-network

volumes:
  open-webui-data:

networks:
  ia-network:
    driver: bridge

Lance le service :

docker compose up -d

Vérifie que tout tourne :

docker compose logs -f open-webui

L'interface est accessible sur http://TON_IP:3000. Crée ton compte administrateur lors de la première connexion (le premier utilisateur inscrit devient admin).

Important : Si Ollama tourne sur le même VPS mais Docker ne le voit pas, remplace host.docker.internal par l'IP locale du VPS ou utilise le mode --network host pour Open WebUI.

Étape 5 : Configurer HTTPS avec Nginx et Let's Encrypt

Exposer l'interface sans HTTPS est un risque majeur. Configure Nginx comme reverse proxy :

# Installer Nginx et Certbot
apt install nginx certbot python3-certbot-nginx -y

Crée le fichier de configuration Nginx :

nano /etc/nginx/sites-available/agent-ia

server {
    listen 80;
    server_name agent.tondomaine.com;

    location / {
        proxy_pass http://localhost: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;

        # Support WebSocket pour les réponses streaming
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";

        proxy_read_timeout 300s;
        proxy_send_timeout 300s;
    }
}

# Activer le site
ln -s /etc/nginx/sites-available/agent-ia /etc/nginx/sites-enabled/
rm /etc/nginx/sites-enabled/default
nginx -t && systemctl reload nginx

# Obtenir le certificat SSL
certbot --nginx -d agent.tondomaine.com

Ton agent IA est maintenant accessible en HTTPS sur https://agent.tondomaine.com.

Renouvellement automatique du certificat :

certbot renew --dry-run

Étape 6 : Sécuriser et optimiser

Voici les optimisations nécessaires pour un agent IA en production :

Sécurité :

# Configurer les mises à jour automatiques de sécurité
apt install unattended-upgrades -y
dpkg-reconfigure -plow unattended-upgrades

# Limiter les connexions SSH
nano /etc/ssh/sshd_config
# Ajouter :
# MaxAuthTries 3
# PermitRootLogin no
# PasswordAuthentication no (si clés SSH configurées)
systemctl restart sshd

Optimisation des performances :

# Augmenter les limites de fichiers ouverts
echo "* soft nofile 65536" >> /etc/security/limits.conf
echo "* hard nofile 65536" >> /etc/security/limits.conf

# Swap si RAM insuffisante (utile pour les petits VPS)
fallocate -l 8G /swapfile
chmod 600 /swapfile
mkswap /swapfile
swapon /swapfile
echo '/swapfile none swap sw 0 0' >> /etc/fstab

Backup automatisé :

# Script de backup hebdomadaire des données Open WebUI
cat > /opt/agent-ia/backup.sh << 'EOF'
#!/bin/bash
DATE=$(date +%Y-%m-%d)
docker exec open-webui tar czf /app/backend/data/backup.tar.gz /app/backend/data
docker cp open-webui:/app/backend/data/backup.tar.gz /opt/backups/open-webui-$DATE.tar.gz
find /opt/backups -name "*.tar.gz" -mtime +30 -delete
EOF
chmod +x /opt/agent-ia/backup.sh

# Ajouter au crontab
echo "0 3 * * 0 /opt/agent-ia/backup.sh" | crontab -

Étape 7 : Ajouter des fonctionnalités avancées

Ton agent IA de base fonctionne. Voici comment le rendre plus puissant :

RAG (Retrieval Augmented Generation) — Pour que ton agent connaisse tes documents :

# Open WebUI intègre nativement le RAG
# Uploadez des PDF, TXT ou documents via l'interface web
# L'agent les indexera automatiquement

Connexion à plusieurs modèles — Alterne entre modèles selon les tâches :

# Télécharge des modèles spécialisés
ollama pull codellama:13b      # Pour le code
ollama pull mistral:7b         # Pour la rédaction en français
ollama pull nomic-embed-text   # Pour les embeddings RAG

API REST pour l'intégration — Utilise Ollama comme backend pour tes automatisations :

# Exemple d'appel API
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.1:8b",
  "prompt": "Résume ce texte en 3 points clés",
  "stream": false
}'

Monitoring avec Netdata (optionnel) :

# Installer Netdata pour surveiller les performances du VPS
curl -Ss https://my-netdata.io/kickstart.sh | bash

Les outils : Docker + Ollama + Open WebUI

Docker isole chaque service dans un conteneur. Mises à jour faciles, rollbacks instantanés, zéro conflit de dépendances. C'est le standard de l'industrie pour un reason.

Ollama est le moteur d'inference. Il gère le téléchargement, le chargement et l'exécution des modèles LLM. Interface CLI simple, API REST complète, optimisé pour les VPS sans GPU.

Open WebUI est ton interface chat. Support multi-utilisateurs, historique, RAG, comparaison de modèles. C'est l'expérience ChatGPT mais chez toi.

Coût total : VPS (10-50€/mois) + domaine (10€/an) = budget prévisible, pas de surprises.

Les erreurs à éviter

Exposer le port Ollama (11434) directement sur internet — C'est une faille de sécurité massive. Ne l'expose JAMAIS sauf si tu as un auth layer devant. Utilise toujours un reverse proxy.
Choisir un VPS trop petit sans comprendre les besoins en RAM — Un modèle 8B nécessite au minimum 8 Go de RAM. Si ton VPS en a 4, le modèle ne chargera pas. Calcule avant d'acheter.
"Oublier" les backups — Docker ne sauvegarde pas les volumes par défaut. Si ton VPS crashe, tu perds tout. Le script de backup n'est pas optionnel.
Ne pas renouveler le certificat SSL — Un HTTPS expiré = ton agent inaccessible. Configure le renouvellement automatique dès le jour 1.
Négliger les mises à jour de sécurité — Un VPS non mis à jour est une cible. Active les mises à jour automatiques de sécurité et redémarre les containers régulièrement.
Vouloir faire tourner un modèle 70B sur un VPS à 10€/mois — Sois réaliste sur le hardware. Commence petit, mesure, puis scale si nécessaire.
Ne pas monitorer les performances — Sans métriques, tu ne sais pas si ton agent rame parce que le modèle est trop gros ou parce que le VPS est sous-dimensionné.

Checklist de déploiement

Avant de te lancer

La limite honnête : L'auto-hébergement demande de la maintenance et des compétences sécurité ; les modèles locaux restent moins puissants que GPT-4/Claude. L'automatisation sans arrêt d'urgence, c'est juste un bug qui travaille plus vite.

L'alternative gratuite : Ollama + Open WebUI (open source, gratuits) ; palier gratuit d'un cloud (ex. offres free tier) pour tester avant de payer un VPS.

L'outil que j'utilise : Hébergeur — [LIEN AFFILIÉ — PLACEHOLDER] (programme de l'hébergeur retenu, « à confirmer »). Docker/GitHub/Ollama : outils gratuits, pas de lien affilié.

Certains liens sont des liens d'affiliation : si tu achètes via eux, je touche une commission, sans surcoût pour toi. (Conditions à vérifier sur le dashboard officiel.)

Récupère la checklist

🎁 La checklist 60 minutes pour construire ton premier système de contenu IA, de l'idée à la publication. → Recevoir la checklist

Sur Instagram : commente VPS sous le Reel et je t'envoie la ressource.