Ce post est la documentation de l’atelier IA autohébergée qui a eu lieu à l’agu3l le 14 novembre 2025.

Table des matières

L’idée de l’atelier est de proposer aux utilisateurs une méthode pour avoir une IA auto-hébergée, ce qui permet de protéger sa vie privée.

On va mettre en place deux outils : un chat, et un générateur d’images.

Il y a deux méthodes proposées : sur une machine locale ou sur une machine cloud fournie par un hébergeur. La machine cloud est intéressante pour ceux qui n’ont pas une machine permettant de faire tourner une IA, surtout pour la partie génération d’images.

Pré-requis

Matériel

Il faut une machine un peu puissante :

  • Au moins 8GB de RAM pour le chat, 16 GB pour la génération d’images
  • Idéalement une carte graphique NVidia ou AMD, mais si besoin on peut utiliser les CPUs
  • Au moins 25 GB sur le disque système (pour les images docker)
  • Au moins 60 GB sur un disque pour les modèles (chat : 10 GB, images : 50 GB)

Logiciels

Il faut donc avoir installé docker sur la machine.

Si on utilise une carte graphique, (installer NVIDIA Container Toolkit pour NVidia en suivant les instructions officielles)[https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html].

sudo nvidia-ctk runtime configure --runtime=docker sudo systemctl restart docker

Installer aussi cuda.

Données

Dans le cadre de l’atelier, on ne veut pas télécharger sur Internet. Créer trois dossiers ollama, openwebui et invokeai sur le disque ayant 60 GB de libre, puis :

  • importer les images docker ollama, openwebui et invokeai dans docker avec la commande docker load -i <image>
  • copier les modèles dans ollama/models
  • copier le cache de openweb-ui
  • copier les modèles dans invokeai/models

Comptes

Pour utiliser une machine public cloud, il vous faudra un compte chez un hébergeur (OVH par exemple) avec un moyen de paiement.

Pour avoir accès à tous les modèles sur invokeai, il vous faudra un compte gratuit sur HuggingFace (https://huggingface.co) et générer un token avec accès en lecture sur votre compte.

Public cloud

Pour ceux qui n’ont pas une machine suffisamment puissante, il est possible de louer une machine virtuelle sur un cloud.

OVH par exemple propose des machines puissantes avec carte graphique à partir de 0.36€/h (HT), soit environ 0.44€/h TTC.

Il faut créer un compte chez OVH, enregistrer un moyen de paiement (carte bancaire), puis aller dans la section Public Cloud et créer une instance.

Il vous faudra aussi une clef ssh (rsa). Si vous n’avez pas de fichier ~/.ssh/id_rsa, générez-en une avec : ssh-keygen -t rsa -f ~/.ssh/id_rsa. Mettez un mot de passe sur votre clef. Lorsqu’on vous demandera votre clef, il faudra donner le contenu de id_rsa.pub (et surtout pas de id_rsa, qui doit toujours rester secret !).

Choisir une instance :

  • GPU > RTX5000-28
  • Région 1-AZ > Graveline 9 (par exemple)
  • Image Distributions + Apps > Docker Debian 12
  • Ajouter une clef en donnant le contenu de id_rsa.pub, puis la sélectionner
  • Nommer l’instance (facultatif), ne pas sélectionner de sauvegarde pour ce projet
  • Choisir le mode public pour accéder à la machine via Internet
  • Vérifier le prix et valider la création

Pour se connecter sur la machine, récupérer l’ip publique qui est affichée sur la page OVH, puis :

ssh debian@<ip>
(Validation : taper yes pour valider la clef de la machine)
sudo -i

La validation de la clef de la machine se fait lorsqu’on se connecte pour la première fois sur une nouvelle machine.

Installer les drivers Nvidia

apt update
apt install linux-headers-$(uname -r)

# Installer NVidia Container Toolkit
apt install -y --no-install-recommends curl gnupg2
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
    && curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
    sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
    sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
apt update

export NVIDIA_CONTAINER_TOOLKIT_VERSION=1.18.0-1
apt install -y \
      nvidia-container-toolkit=${NVIDIA_CONTAINER_TOOLKIT_VERSION} \
      nvidia-container-toolkit-base=${NVIDIA_CONTAINER_TOOLKIT_VERSION} \
      libnvidia-container-tools=${NVIDIA_CONTAINER_TOOLKIT_VERSION} \
      libnvidia-container1=${NVIDIA_CONTAINER_TOOLKIT_VERSION}
systemctl restart docker

# Installer les drivers NVidia
wget https://developer.download.nvidia.com/compute/cuda/repos/debian12/x86_64/cuda-keyring_1.1-1_all.deb
dpkg -i cuda-keyring_1.1-1_all.deb
apt update
apt -V install nvidia-driver-cuda nvidia-kernel-dkms
apt -V install nvidia-container-toolkit
reboot

# Finalisation
mkdir -p /srv/{ollama,open-webui,invokeai}
docker ps
cat /proc/driver/nvidia/version

Si les dernières lignes après le reboot indiquent que docker tourne (par d’erreur) et renvoient une version d’un driver NVIDIA, le machine est prête.

Note : avec ces machines, il est possible de faire tourner des modèles beaucoup plus gros.

Arrêter la machine

Attention : éteindre la machine ne coupe pas la facturation.

Pour ne pas avoir à refaire toutes les manipulations, il est possible de faire une sauvegardes des données (pas de l’ip). Vous ne payez que le stockage des données (voir les conditions, ça devrait coûter 0.011€/Go/mois HT, soit pour 100 Go, 1.32€/mois TTC).

Lorsque vous avez terminé, pensez à supprimer la machine pour ne plus être facturés.

Chat

Le chat tourne avec ollama comme moteur, et on va utiliser Openweb-UI comme interface.

Installer ollama

docker run -d --gpus=all -v /srv/ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

NOTE: Le port 11434 est le port utilisé par défaut par openweb-ui. Si vous le changez ici, il faudra configurer openweb-ui.

Lorsqu’on démarre ollama, il va automatiquement télécharger le modèle indiqué s’il n’est pas déjà installé, mais nous l’avons déjà importé manuellement. Les modèles disponibles sont consultables ici : https://ollama.com/search Le modèle doit rentrer dans la ram disponible : arrêter ollama et faire free -h. La colonne « disponible » indique la RAM dispo pour le modèle.

Les modèles que nous avons téléchargés sont :

  • mistral-nemo (12b, 7.1 GB, généraliste)
  • dolphin3:8b (8b, 4.9 GB, génération de code)
  • gemma3:270m (270M)
  • granite4:micro (3.4b, 2.1 GB, généraliste, résultats impressionnants pour la taille)
  • granite4:tiny-h (7b, 4.2 GB, généraliste)

Démarrer le modèle :

docker exec -it ollama ollama run gemma3:270m

Configurer le prompt avec /set system "Utilise le français" puis discuter avec lui. /bye permet de quitter.

Installer openweb-ui

Créer un dossier <mon_chemin> (/srv/ par exemple) qui sera utilisé pour stocker les données.

docker run -d -p 8080:8080 --gpus all --add-host=host.docker.internal:host-gateway -v /srv/open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:cuda

Se connecter sur http://localhost:8080`

Utilisation

Essayer l’intégration de recherche sur le web.

Essayer la reconnaissance vocale.

Le text-to-speech (lecture de la réponse à haute voix) local ne supporte malheureusement que l’anglais à ce jour. Aller dans le Panneau Admin -> Réglages -> Audio -> Text to Speech et choisir le moteur Transformers.

Il est possible d’utiliser Kokoro Web en local, mais il ne fait que : anglais (uk et us), japonais, chinois, espagnol, italien, portugais et hindi.

InvokeAI

NOTE: On peut probablement pas faire tourner en même temps ollama/openwebui et invokeai sur la RAM locale. Arrêter ollama et openwebui pour utiliser invokeai.

Si nécessaire, configurer invokeai pour autoriser l’usage de cartes avec peu de VRAM : ajouter enable_partial_loading: true dans invokeai.yaml et redémarrer.

echo "enable_partial_loading: true" >> /srv/invokeai/invokeai.yaml
sudo docker run --gpus=all -p 9090:9090 -v /srv/invokeai/models:/invokeai/models --name invokeai ghcr.io/invoke-ai/invokeai

Importer des modèles

Se connecter sur le port 9090 : http://:9090

Cliquer sur l’icone Models en bas à gauche.

Si des modèles ont été copiés, faire un scan de /invokeai/models et installer les modèles.

Dans le site HuggingFace, créer un token : image du compte -> Access Token -> READ. Copier le token dans un keepass ou équivalent.

Dans l’onglet HugginFace de InvokeAI, insérer le token.

Choisir l’un des trois modèles : SDXL (Juggernaut) est bien. FLUX1 est le plus performant mais je n’ai jamais réussi à le faire fonctionner (oui c’est un défi !).

Générer des images

Choisir un style, entrer un prompt, puis cliquer sur Invoke.