ComfyUI sur Fedora 43 : Deux environnements virtuels + Démarrage en un clic (mars 2026)

ComfyUI sur Fedora 43 : Deux environnements virtuels + Démarrage en un clic (mars 2026)
Date : Mars 2026
OS : Fedora 43
Objectif : Conserver deux venvs Python (ex. 3.12 + 3.14) pour la compatibilité, mais démarrer ComfyUI automatiquement avec une configuration propre et légère.
Enterprise Delivery Operating System
Ce guide fait partie de la série Enterprise Delivery Operating System. Utilisez ces hubs de catégories pour naviguer dans l'ensemble de la pile (infra → workflows → gouvernance).
ArchitectureArchitecture de référence pour l'Enterprise Delivery Operating System.
DevOps & RuntimeDéploiements, services, ports, opérations d'exécution et répétabilité.
Outils IA & AutomatisationPile IA locale, orchestration, automatisation et workflows stables.
Sécurité & ConformitéPermissions, durcissement et paramètres par défaut sécurisés pour les systèmes d'IA locaux.
Observabilité & PerformanceOptimisation des performances, surveillance, budgétisation VRAM/RAM et stabilité.
Pourquoi conserver deux venvs ?
Les outils d'IA évoluent rapidement. Certains nœuds et wheels sont en retard sur la version la plus récente de Python, tandis que d'autres l'exigent.
- venv Python 3.12 → « ennuyeux mais compatible » (TensorRT/LW wheels/Lightning sont souvent plus stables)
- venv Python 3.14 → fonctionnalités les plus récentes, mais les wheels manquantes / problèmes d'importation sont courants
Règle : ne mélangez jamais les installations entre les venvs. Lancez toujours ComfyUI depuis le venv souhaité.
Configuration : Un script par venv
Créez un petit script de lancement qui :
1) se déplace dans le dossier ComfyUI
2) active le venv choisi
3) lance ComfyUI sur localhost
1) Créer un lanceur pour le venv Python 3.12
mkdir -p ~/.local/bin
cat > ~/.local/bin/comfyui-start-312.sh <<'EOF'
#!/usr/bin/env bash
set -euo pipefail
cd /home/x/ai/ComfyUI
source /home/x/ai/ComfyUI/.venv312/bin/activate
exec python main.py --listen 127.0.0.1 --port 8188
EOF
chmod +x ~/.local/bin/comfyui-start-312.sh
2) (Optionnel) Créer un lanceur pour le venv Python 3.14
cat > ~/.local/bin/comfyui-start-314.sh <<'EOF'
#!/usr/bin/env bash
set -euo pipefail
cd /home/x/ai/ComfyUI
source /home/x/ai/ComfyUI/.venv/bin/activate
exec python main.py --listen 127.0.0.1 --port 8189
EOF
chmod +x ~/.local/bin/comfyui-start-314.sh
Maintenant, vous pouvez exécuter l'une ou l'autre version sans réfléchir :
- ~/.local/bin/comfyui-start-312.sh
- ~/.local/bin/comfyui-start-314.sh
Démarrage automatique : service utilisateur systemd (meilleure option)
Cela lance ComfyUI à la connexion, redémarre en cas de plantage et reste minimaliste (pas de root, pas de wrappers lourds).
1) Créer le service utilisateur pour 3.12
mkdir -p ~/.config/systemd/user
cat > ~/.config/systemd/user/comfyui312.service <<'EOF'
[Unit]
Description=ComfyUI (Python 3.12 venv)
After=network.target
[Service]
Type=simple
WorkingDirectory=/home/x/ai/ComfyUI
ExecStart=/home/x/.local/bin/comfyui-start-312.sh
Restart=on-failure
RestartSec=2
Environment=PYTHONUNBUFFERED=1
[Install]
WantedBy=default.target
EOF
2) Activer + démarrer
systemctl --user daemon-reload
systemctl --user enable --now comfyui312.service
systemctl --user status comfyui312.service --no-pager
3) Journaux (débogage)
journalctl --user -u comfyui312.service -f
(Si vous voulez aussi le service 3.14, répétez l'opération avec comfyui314.service et l'autre script.)
GUI en un clic : Lanceur de bureau (ouvrir ComfyUI dans le navigateur)
Ceci crée une entrée d'application dans votre menu. En cliquant dessus :
1) lance le service
2) ouvre l'interface dans votre navigateur
mkdir -p ~/.local/share/applications
cat > ~/.local/share/applications/comfyui.desktop <<'EOF'
[Desktop Entry]
Type=Application
Name=ComfyUI (Local)
Comment=Start ComfyUI and open the UI
Exec=sh -lc 'systemctl --user start comfyui312.service; xdg-open http://127.0.0.1:8188'
Icon=utilities-terminal
Terminal=false
Categories=Graphics;AI;
EOF
Notes pour éviter les erreurs courantes
- Si vous voyez pip s'installer dans ~/.local/..., vous n'êtes pas dans le bon venv (ou vous ne l'avez pas activé).
- Si un nœud échoue avec pkg_resources manquant → installez setuptools à l'intérieur du venv choisi : source /home/x/ai/ComfyUI/.venv312/bin/activatepython -m pip install -U pip setuptools wheel
- Les échecs des nœuds TensorRT sont normaux sur les versions plus récentes de Python : si vous n'en avez pas besoin, désactivez ce dossier de nœuds personnalisés.
Lectures suivantes
Si vous souhaitez approfondir, ces guides se connectent directement à la configuration ci-dessus :
Nœuds ComfyUI : corrections de dépendances (Lightning, pkg_resources, ffmpeg)Corrigez les échecs d'importation de nœuds courants et maintenez la stabilité de votre pile ComfyUI au fil des mises à jour.
Deux venvs, deux ports, zéro confusionExécutez proprement plusieurs instances de ComfyUI : ports, services et profils prévisibles.
Budgétisation de la VRAM : ce qui réduit réellement les OOMTactiques pratiques pour la VRAM : modes d'attention, tailles de modèles, traitement par lots et limites réelles.
Sécurisation de l'IA locale : permissions, sandboxing et paramètres par défaut sécurisésRéduisez les risques sur les systèmes d'IA locaux : permissions de fichiers, isolation des services et paramètres par défaut plus sûrs.
Compromis (rapide)
service utilisateur systemd
- ✅ stable, redémarrage automatique, faible surcharge, propre
- ⛔ nécessite une configuration initiale unique
lanceur de bureau
- ✅ flux de travail en un clic
- ⛔ dépend toujours de l'interface utilisateur du navigateur
deux venvs
- ✅ le meilleur des deux mondes (compatibilité + dernières versions)
- ⛔ vous devez séparer les ports/services pour éviter toute confusion
Related Articles

OpenAI Agents API vs Agents SDK vs Responses API : sur quoi devriez-vous construire en 2026 ?
La stack d'agents d'OpenAI a changé en septembre 2026. Ce guide d'architecture sépare l'API Agents, le SDK Agents, l'API Responses et le SDK Codex selon la propriété du runtime — afin que les équipes puissent choisir la bonne limite de contrôle au lieu de comparer des noms de produits.

Google I/O 2026 : pivots architecturaux, IA agentique et confrontation à la réalité de l'écosystème unifié
Google I/O 2026 n'était pas seulement un événement dédié aux modèles. Il a révélé une transition de plateforme plus profonde à travers les modèles Gemini, les outils de développement, les interfaces liées à Android et les appareils intelligents. Cet article décrypte la keynote comme un article de référence pour les ingénieurs, les architectes et les équipes produit qui doivent distinguer les implications réelles sur le runtime de la hype des présentations sur scène.

Guide complet des déclencheurs de rollback dans les runbooks IA d'entreprise
Ce guide explore les déclencheurs de rollback, mécanismes essentiels dans les runbooks d'IA d'entreprise qui détectent automatiquement les anomalies et initient des rollbacks pour maintenir la stabilité du système. Apprenez à configurer, surveiller et optimiser ces déclencheurs pour des déploiements d'IA robustes.

Quectel RM500U-EA dans le ZBT Z8102AX : bandes 5G, o2 Allemagne et comportement du signal en conditions réelles
Le ZBT Z8102AX utilise un modem Quectel RM500U-EA pour la connectivité 4G et 5G. Lors du premier test pratique, le routeur s'est connecté avec succès à o2 Germany avec la bande LTE 3 et la NR n28. Le modem fonctionne, mais des diagnostics plus approfondis tels que le RSRP, le RSRQ, le SINR, le verrouillage de bande et le comportement des cellules nécessitent encore des tests appropriés.

Pourquoi plus de contexte peut rendre les réponses de l'IA pires
Une fenêtre de contexte plus grande ne garantit pas une meilleure réponse. Cet article explique comment la dilution du signal, les preuves contradictoires, l'état obsolète, la sensibilité à la position et la compression avec perte peuvent réduire la fiabilité de l'IA — et présente un test pratique de pression de contexte.

Ollama n'est pas le produit : construire des applications Open-LLM prêtes pour la production
Exécuter un modèle local avec Ollama est facile. Construire une application Open-LLM prête pour la production est plus difficile : cela nécessite du RAG, du contrôle d'accès, de l'abstraction de fournisseur, de l'évaluation, de la journalisation, de la discipline de déploiement et une couche applicative contrôlée autour du modèle.

Qu’est-ce que l’ingénierie du contexte ? Ce que le modèle reçoit avant de répondre
L'ingénierie de contexte conçoit les informations qu'un modèle d'IA reçoit avant l'inférence, y compris les invites, la récupération, la mémoire, l'état de l'application, les résultats d'outils et l'historique des conversations.

Invariance du prompt : la conclusion survit-elle au prompt ?
Une méthodologie pratique pour tester si la conclusion d'une IA dépend de la manière dont un problème a été formulé. Prompt Invariance compare des formulations originales, en aveugle, inversées et contradictoires, tout en maintenant la structure des preuves sous contrôle.

D'où un LLM tire-t-il ses données ? Sources de données RAG en Python
Un LLM ne connaît pas magiquement vos fichiers, bases de données ou API. Cette suite pratique de la série sur le RAG montre, avec du Python simple, comment des données externes deviennent des preuves récupérables : des fichiers texte et du SQL à la recherche en texte intégral, aux embeddings, à l'assemblage du contexte et à l'appel final au LLM.

Comment savoir si un agent IA a réellement utilisé les bonnes preuves
Un agent IA peut citer des sources et tout de même utiliser les mauvais éléments de preuve. Cet article présente une méthode pratique pour vérifier le soutien des affirmations, l'autorité de la source, l'applicabilité, la provenance et si les éléments de preuve ont réellement influencé la réponse.

À quelle distance se trouve une affirmation d’IA des preuves ? — Distance aux preuves
Toutes les réponses étayées ne sont pas également proches de leurs preuves. La distance aux preuves est un moyen pratique de décrire combien de transformations, de résumés, d'hypothèses et d'étapes inferentielles séparent une affirmation de l'IA de preuves directement inspectables.

Une Architecture Monorepo Pratique avec Next.js, Fastify, Prisma, et NGINX
Explorez une architecture de monorepo pratique utilisant Next.js, Fastify, Prisma et NGINX, mettant en évidence l'intégration et le flux de travail concrets.