VRAM Tuning (Partie 2) : Passer sous Linux pour libérer votre GPU

On se retrouve pour la suite de notre dossier sur l’optimisation de la VRAM. Dans la partie 1, on a vu comment gratter chaque Mo possible sur Windows. Mais soyons honnêtes : au bout d’un moment, on se cogne contre les limites du système lui-même. 🛑

Le constat : Windows est trop gourmand

Même avec 32 Go de RAM et un nettoyage complet des applications au démarrage, Windows a cette fâcheuse tendance à s’étendre. Chez moi, il finit par occuper entre 9 et 10 Go de RAM juste pour « exister », malgré toutes les optimisations possibles.

Côté VRAM, c’est le même combat. Même en suivant les astuces de mon article précédent pour réduire la consommation de l’interface, Windows garde toujours une « taxe » de 400 à 500 Mo sur votre GPU. Ça paraît peu ? Sur une carte de 16 Go comme la RTX 5070 Ti ou la RTX 5080, c’est pourtant la différence entre charger un gros modèle Flux ou avoir une erreur « Out of Memory ». 📉

En comparaison, une installation Ubuntu bien configurée ne consomme que 20 Mo de VRAM. Le calcul est vite fait : on rend son potentiel brut à la carte graphique.

Pourquoi Ubuntu + Docker ?

Si vous avez une carte performante avec 16 Go de VRAM, utiliser Ubuntu est le meilleur choix pour l’IA. Pour garder un système propre, j’ai opté pour Docker. C’est la méthode la plus robuste : on évite les conflits de versions Python (le fameux « Python hell ») et on garde un environnement isolé. 🐳

Ce guide vous explique comment installer ComfyUI, configurer l’accès au GPU et lier vos modèles déjà existants (issus de Stability Matrix par exemple) pour ne pas gaspiller d’espace disque.

1. Vérification des prérequis matériels 🖥️

Avant de commencer, on doit s’assurer que ta carte graphique est bien reconnue par Ubuntu. C’est la base indispensable pour que tout le reste fonctionne.

Ouvre un terminal et tape :

nvidia-smi

Tu devrais voir un tableau s’afficher. Ce qui nous intéresse ici, c’est que le nom de ta carte apparaisse bien et que la Driver Version soit à jour (idéalement au-dessus de 550 pour les cartes récentes). Si ce tableau s’affiche, ton pilote est opérationnel.

2. Installation de Docker : Le moteur de ton projet ⚙️

Docker va nous permettre d’isoler ComfyUI. Au lieu d’installer des dizaines de bibliothèques directement sur ton Ubuntu, on va créer un « conteneur » qui contiendra tout le nécessaire.

Pourquoi Docker ?

  • Propreté : Si tu veux supprimer ComfyUI un jour, tu supprimes juste le conteneur, et ton système reste comme neuf.
  • Isolation : Pas de conflit entre tes différents projets IA.
  • Simplicité : On utilise une « recette » précise qui fonctionne à tous les coups.

Les étapes d’installation

Tape ces commandes pour installer Docker de manière propre (version officielle) :

# Mise à jour des dépôts
sudo apt-get update
sudo apt-get install ca-certificates curl gnupg

# Ajout de la clé GPG officielle de Docker
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# Configuration du dépôt stable
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Installation finale
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

3. Le pont vers le GPU : NVIDIA Container Toolkit 🌉

Par défaut, Docker ne peut pas voir ta carte graphique. Il faut installer un « pont » qui permet au conteneur d’utiliser la puissance de calcul de ta RTX.

# Configuration du dépôt NVIDIA
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

# Installation et configuration
sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

4. Préparation de l’environnement ComfyUI 🎨

On va créer un dossier dédié pour notre installation. On va y placer deux fichiers : un pour construire l’image et un pour gérer le lancement.

mkdir ~/comfyui-station && cd ~/comfyui-station

Le fichier Dockerfile

Ce fichier contient la « recette » de notre environnement. Il va télécharger une base NVIDIA/PyTorch stable et y installer ComfyUI.

Tape nano Dockerfile et colle ceci :

# On part d'une base CUDA solide
FROM pytorch/pytorch:2.2.1-cuda12.1-cudnn8-runtime

# Installation des dépendances système pour OpenCV et Git
RUN apt-get update && apt-get install -y \
    git \
    libgl1-mesa-glx \
    libglib2.0-0 \
    && rm -rf /var/lib/apt/lists/*

# Clonage de ComfyUI
WORKDIR /opt
RUN git clone https://github.com/comfyanonymous/ComfyUI.git

# Installation des dépendances Python de base
WORKDIR /opt/ComfyUI
RUN pip install --no-cache-dir -r requirements.txt

# --- AJOUT CRUCIAL POUR TON BLOG ---
# On installe les bibliothèques requises par les extensions populaires
# (Manager, Crystools, Lora Manager, etc.)
RUN pip install --no-cache-dir piexif deepdiff py-cpuinfo natsort pynvml toml GitPython

# Lancement du serveur
EXPOSE 8188
CMD ["python", "main.py", "--listen", "0.0.0.0"]

5. Mapping des modèles existants (Stability Matrix) 🧠

C’est l’étape cruciale pour ne pas perdre de place. Si tu as déjà tes modèles (Checkpoints, Lora, VAE) sur un disque dur séparé, on va les « monter » directement dans le conteneur.

Le fichier docker-compose.yml

Tape nano docker-compose.yml et adapte les chemins vers ton disque de données :

services:
  comfyui:
    build: .
    container_name: comfyui
    runtime: nvidia
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
    ports:
      - "8188:8188"
    volumes:
      # --- STOCKAGE DES MODÈLES (À adapter selon votre disque) ---
      # Remplacez /media/NOM_UTILISATEUR/DISQUE/ par votre chemin réel
      - /media/user/DATA/Models/StableDiffusion:/opt/ComfyUI/models/checkpoints
      - /media/user/DATA/Models/Lora:/opt/ComfyUI/models/loras
      - /media/user/DATA/Models/VAE:/opt/ComfyUI/models/vae
      
      # --- DONNÉES LOCALES (Persistance dans le dossier du projet) ---
      - ./custom_nodes:/opt/ComfyUI/custom_nodes # Vos extensions
      - ./user:/opt/ComfyUI/user                 # Vos réglages (langue, thèmes)
      - ./output:/opt/ComfyUI/output             # Vos images générées

    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    
    # "no" pour garder le contrôle manuel, "unless-stopped" pour un démarrage auto
    restart: "no"

6. Lancement et Monitoring 📊

Tout est prêt. On lance la construction et le démarrage :

sudo docker compose up -d --build

Docker va maintenant télécharger les composants (plusieurs Go) et préparer ton serveur. Tu peux suivre l’avancée avec :

sudo docker logs -f comfyui

Surveiller tes ressources

Une fois que ComfyUI est lancé sur http://localhost:8188, il est important de surveiller la charge de ta carte. Je te conseille d’installer nvtop sur ton Ubuntu :

sudo apt install nvtop
nvtop

Cela t’affichera des graphiques magnifiques sur l’utilisation de ta VRAM et de ton GPU en temps réel.

7. Installation du Manager et de Crystools 🛠️

Pour que ton expérience soit complète, tu as besoin du ComfyUI-Manager. Puisque nous avons mappé le dossier custom_nodes, tu peux l’installer directement depuis ton Ubuntu :

cd ~/comfyui-station/custom_nodes
git clone https://github.com/ltdrdata/ComfyUI-Manager.git

Redémarre le conteneur (sudo docker compose restart) et tu verras le bouton Manager apparaître. Utilise-le pour installer Crystools, qui te permettra d’avoir tes statistiques de ressources directement dans l’interface web.

8. Garder le contrôle : Le mode « Démarrage Manuel » 🕹️

Avoir ComfyUI qui tourne en arrière-plan, c’est pratique, mais sur une machine de guerre, on veut parfois récupérer 100 % de sa VRAM pour lancer un jeu gourmand ou un logiciel de montage sans que Docker ne vienne grignoter des ressources.

Voici comment configurer ton installation pour qu’elle ne s’allume que lorsque tu le décides.

1. Modifier la règle de redémarrage

Par défaut, nous avons configuré Docker pour qu’il relance ComfyUI automatiquement au démarrage du PC. Pour changer cela, ouvre ton fichier de configuration :

nano ~/comfyui-station/docker-compose.yml

Modifie la ligne restart tout en bas :

  • Ancienne version : restart: unless-stopped
  • Nouvelle version : restart: "no"

Applique le changement avec un petit : sudo docker compose up -d. Désormais, au prochain démarrage d’Ubuntu, ComfyUI restera sagement éteint.

2. Le pilotage « Clic-Bouton » avec Portainer

C’est là que Portainer prend tout son sens. Au lieu de taper des lignes de commande, tu as maintenant une télécommande visuelle :

  1. Ouvre ton interface Portainer.
  2. Dans l’onglet Containers, tu verras ton conteneur comfyui avec un voyant gris (stopped).
  3. Quand tu as une idée de création : coche la case et clique sur Start.
  4. Une fois ta session finie : clique sur Stop. Ta carte graphique retombe instantanément à 0% d’utilisation.

Conclusion 🏁

Tu as maintenant une installation de ComfyUI professionnelle :

  1. Performante : Accès direct au GPU via NVIDIA Container Toolkit.
  2. Organisée : Tes modèles restent sur ton disque DATA.
  3. Évolutive : Tu peux mettre à jour ComfyUI ou tester d’autres versions sans jamais polluer ton système Ubuntu principal.

Il ne te reste plus qu’à charger ton premier modèle et à laisser libre cours à ta créativité !

Dernier conseil de sécurité : Pense à faire une copie de ton dossier ~/comfyui-station (surtout les fichiers Dockerfile et docker-compose.yml) sur une clé USB ou un cloud. Si tu réinstalles ton Ubuntu un jour, tu récupéreras ton usine à images en exactement 2 minutes.

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *