For AI agents: the complete documentation index is available at https://docs.ovhcloud.com/fr/llms.txt, the full documentation bundle is available at https://docs.ovhcloud.com/fr/llms-full.txt, and this page is available as Markdown at https://docs.ovhcloud.com/fr/guides/public-cloud/ai-machine-learning/ai-deploy-flux-models.md.

AI Deploy - Tutoriel - Déployer des modèles Text-to-Image FLUX

Voir en Markdown

Comment déployer les modèles de génération d'images FLUX en utilisant ComfyUI

Info

AI Deploy est couvert par les Conditions particulières OVHcloud Public Cloud.

Introduction

FLUX est une famille flexible de modèles génératifs développée par Black Forest Technologies. Les modèles FLUX prennent en charge diverses tâches, notamment la génération d’images à partir de texte, le conditionnement structurel et l’inpainting.

Dans ce tutoriel, nous allons parcourir le processus de déploiement des modèles FLUX sur AI Deploy. Nous vous montrerons comment utiliser les modèles FLUX de manière interactive avec ComfyUI (une interface de programmation visuelle).

En pratique

Vous allez suivre différentes étapes pour déployer votre modèle FLUX :

Choisir la variante de modèle FLUX

FLUX est disponible en plusieurs variantes, chacune adaptée à des cas d’usage spécifiques, de l’inférence texte-image à l’édition d’images avancée. Ces variantes diffèrent par leurs besoins en mémoire, leurs performances et leurs conditions de licence.

Le tableau suivant liste les principales variantes de FLUX et leurs cas d’usage prévus :

NomUsageDépôt HuggingFaceLicence
FLUX.1 [schnell]Texte vers imageDépôt Schnellapache-2.0
FLUX.1 [dev]Texte vers imageDépôt DevFLUX.1-dev Non-Commercial License
FLUX.1 Kontext [dev]Édition d’imagesDépôt KontextFLUX.1-dev Non-Commercial License

La liste complète est disponible sur le dépôt officiel des modèles FLUX.1.

Prérequis

Avant de continuer, assurez-vous de disposer des éléments suivants :

  • Un projet AI Deploy créé au sein d’un projet Public Cloud de votre compte OVHcloud
  • Un utilisateur pour AI Training & Object Storage
  • L’AI CLI OVHcloud installée sur votre ordinateur
  • Docker installé sur votre ordinateur, ou un accès à une instance Docker Debian, disponible sur le
  • Un compte Hugging Face, avec un accès au modèle FLUX. Vous devez accepter les conditions d’utilisation sur la page Hugging Face du modèle.
  • Un token d’accès Hugging Face (générez-en un depuis votre compte Hugging Face → Access Tokens). Celui-ci sera utilisé pour vous authentifier et télécharger les poids du modèle.

Télécharger les poids du modèle dans l’Object Storage OVHcloud

Pour exécuter l’inférence sur AI Deploy, vous devrez d’abord télécharger les poids du modèle depuis Hugging Face et les envoyer vers un conteneur Object Storage OVHcloud. Ce conteneur sera ensuite monté dans votre app AI Deploy à l’exécution, vous permettant d’accéder au modèle téléchargé.

Plutôt que de télécharger et d’envoyer les fichiers manuellement, nous allons automatiser ce processus en lançant un job AI Training court. Ce job va :

  • S’authentifier auprès de Hugging Face à l’aide de votre token
  • Créer un conteneur
  • Importer les packages
  • Télécharger les poids du modèle nécessaires
  • Les stocker dans le conteneur Object Storage créé

Pour lancer ce job, exécutez la commande ovhai suivante dans votre terminal, en remplaçant <your_huggingface_token> par votre token réel :

Schnell
Dev
Kontext Dev
ovhai job run ovhcom/ai-training-pytorch \
  --cpu 2 \
  --name clone-flux-schnell-weights \
  --volume flux-schnell@GRA/:/workspace/flux-model:RW \
  --env HF_TOKEN=<your_huggingface_token> \
  -- bash -c "pip install 'huggingface_hub[hf_transfer]' && \
    huggingface-cli download black-forest-labs/FLUX.1-schnell \
      --token \$HF_TOKEN \
      --local-dir /workspace/flux-model \
      --local-dir-use-symlinks False && \
    huggingface-cli download comfyanonymous/flux_text_encoders \
      --token \$HF_TOKEN \
      --local-dir /workspace/flux-model/comfyanonymous/clip \
      --local-dir-use-symlinks False && \
    rm -rf /workspace/flux-model/.cache \
           /workspace/flux-model/comfyanonymous/clip/.cache"

Cette commande va :

  • Lancer un job basé sur l’image Docker ovhcom/ai-training-pytorch.
  • Créer (s’il n’existe pas déjà) un conteneur nommé flux-schnell, flux-dev ou flux-kontext selon la variante FLUX utilisée, et le monter sur /workspace/flux-model.
  • Installer la bibliothèque huggingface_hub.
  • Télécharger le modèle FLUX et son encodeur de texte à l’aide de huggingface-cli download.
  • Enregistrer les fichiers du modèle dans le conteneur Object Storage monté.
  • Nettoyer les caches locaux de Hugging Face.

Vous pouvez suivre la progression de votre job à l’aide des commandes suivantes :

ovhai job list
ovhai job logs -f <job_id>

Cela vous permettra de consulter les logs générés par votre job, avec les imports et les téléchargements de fichiers (le téléchargement de gros fichiers de modèle peut prendre quelques minutes). Une fois les poids du modèle téléchargés, le job passera à l’état FINALIZING si vous listez vos jobs existants. Cela signifie que les fichiers sont en cours de synchronisation vers le conteneur Object Storage monté. Une fois la synchronisation terminée, le job sera marqué comme DONE.

Vous pouvez ensuite vérifier la présence de vos fichiers en consultant votre conteneur Object Storage depuis l’espace client OVHcloud, ou via la CLI avec la commande suivante :

ovhai bucket object list <bucket_name>@GRA

Construire une image Docker

Une fois les poids du modèle FLUX envoyés vers l’Object Storage, l’étape suivante consiste à construire une image Docker packageant ComfyUI et ses dépendances nécessaires.

Cette image sera ensuite déployée en tant qu’application AI Deploy, où les fichiers du modèle seront montés à l’exécution depuis l’Object Storage. Cela évite d’avoir à intégrer directement les poids volumineux du modèle dans l’image du container.

Créer le Dockerfile

Dans un nouveau dossier, créez le Dockerfile suivant. Il construit un environnement CUDA pour ComfyUI :

FROM nvidia/cuda:12.1.1-cudnn8-runtime-ubuntu22.04

# Install system dependencies
RUN apt-get update && apt-get install -y \
    git wget curl python3 python3-pip libgl1 libglib2.0-0 \
    && rm -rf /var/lib/apt/lists/*

# Create working directory
WORKDIR /app

# Install PyTorch with CUDA 12.1 support
RUN pip install --no-cache-dir torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

# Clone ComfyUI and install its requirements
RUN git clone https://github.com/comfyanonymous/ComfyUI.git /app/ComfyUI
WORKDIR /app/ComfyUI
RUN pip install --no-cache-dir -r requirements.txt

# Return to root app directory
WORKDIR /app

# Add entrypoint and inference script
COPY entrypoint.sh .

# Make entrypoint executable and fix permissions for OVHcloud user
RUN chmod +x entrypoint.sh
RUN chown -R 42420:42420 /app
ENV HOME=/app

# Start ComfyUI via the entrypoint
ENTRYPOINT ["/app/entrypoint.sh"]

Ajouter le script entrypoint.sh

Ce script met en place des liens symboliques vers les fichiers du modèle montés à l’exécution, garantissant que ComfyUI retrouve les poids du modèle téléchargés. En effet, ComfyUI attend les modèles dans des dossiers spécifiques, à l’intérieur de /app/ComfyUI/models.

En reliant les modèles depuis /workspace (où l’Object Storage sera monté) vers les emplacements attendus par ComfyUI, nous évitons les copies de fichiers redondantes et gardons l’image légère.

#!/bin/bash

set -e

# Required env vars
BUCKET_MOUNT_PATH=${BUCKET_MOUNT_PATH:-/workspace/flux-model}
FLUX_VARIANT=${FLUX_VARIANT:-base}  # options are base | kontext

UNET_FILE=${UNET_FILE:-flux1-schnell.safetensors}
DIFFUSION_MODEL_FILE=${DIFFUSION_MODEL_FILE:-flux1-kontext-dev.safetensors}
VAE_FILE=${VAE_FILE:-ae.safetensors}
CLIP_FILE_1=${CLIP_FILE_1:-clip_l.safetensors}
CLIP_FILE_2=${CLIP_FILE_2:-t5xxl_fp16.safetensors}

# symlinks
if [[ "$FLUX_VARIANT" == "kontext" ]]; then
    echo "→ Deploying Flux Kontext variant"
    ln -sf "${BUCKET_MOUNT_PATH}/${DIFFUSION_MODEL_FILE}" "/app/ComfyUI/models/diffusion_models/${DIFFUSION_MODEL_FILE}"
else
    echo "→ Deploying base (Schnell or DEV) FLUX variant"
    ln -sf "${BUCKET_MOUNT_PATH}/${UNET_FILE}" "/app/ComfyUI/models/unet/${UNET_FILE}"
fi

ln -sf "${BUCKET_MOUNT_PATH}/${VAE_FILE}" "/app/ComfyUI/models/vae/${VAE_FILE}"
ln -sf "${BUCKET_MOUNT_PATH}/comfyanonymous/clip/${CLIP_FILE_1}" "/app/ComfyUI/models/clip/${CLIP_FILE_1}"
ln -sf "${BUCKET_MOUNT_PATH}/comfyanonymous/clip/${CLIP_FILE_2}" "/app/ComfyUI/models/clip/${CLIP_FILE_2}"

# Start ComfyUI
exec python3 /app/ComfyUI/main.py --listen 0.0.0.0 --port 8188

Selon la variante FLUX, les fichiers et emplacements attendus peuvent varier. Ce script adapte les emplacements, quelle que soit la version utilisée parmi Schnell, Dev et Kontext.

Construire l’image Docker

Ensuite, lancez l’une des commandes suivantes depuis le dossier créé, qui contient votre Dockerfile et le script entrypoint.sh, pour construire l’image de votre application :

# Build the image using your machine's default architecture
docker build -t flux-image:latest .
 

# Build image targeting the linux/amd64 architecture
docker buildx build --platform linux/amd64 -f Dockerfile -t flux-image:latest .

  • La première commande construit l’image en utilisant l’architecture par défaut de votre système. Cela peut fonctionner si votre machine utilise déjà l’architecture linux/amd64, requise pour exécuter des containers avec nos produits AI. Cependant, sur des systèmes ayant une architecture différente (par exemple ARM64 sur Apple Silicon), l’image obtenue ne sera pas compatible et ne pourra pas être déployée.

  • La seconde commande cible explicitement l’architecture linux/amd64 afin de garantir la compatibilité avec nos services AI. Elle nécessite buildx, qui n’est pas installé par défaut. Si vous n’avez jamais utilisé buildx, vous pouvez l’installer en exécutant : docker buildx install

Envoyer l’image vers un registre

Une fois l’image construite, taguez-la et envoyez-la vers un registre de containers.

Dans cet exemple, nous utilisons le registre partagé OVHcloud, disponible pour chaque utilisateur d’AI Deploy. Mais vous pouvez également utiliser d’autres registres tels que le Managed Private Registry OVHcloud, Docker Hub, GitHub packages, etc.

Warning

Le registre partagé doit être utilisé uniquement à des fins de test. Nous vous recommandons de rattacher votre propre registre. Plus d’informations à ce sujet sont disponibles ici. Les images envoyées vers ce registre sont réservées aux workloads AI Tools et ne seront pas accessibles pour des usages externes.

Trouvez l’adresse de votre registre partagé en lançant cette commande :

ovhai registry list

Connectez-vous au registre partagé avec vos identifiants habituels d’utilisateur AI Platform :

docker login -u <user> -p <password> <registry_address>

Taguez l’image compilée et envoyez-la vers votre registre :

docker tag flux-image <registry_address>/flux-image:latest
docker push <registry_address>/flux-image:latest

Déployer l’app

Une fois votre image Docker construite et les poids du modèle disponibles dans l’Object Storage, vous êtes prêt à déployer votre application sur AI Deploy.

Exécutez la commande suivante pour déployer votre application :

Schnell
Dev
Kontext Dev
ovhai app run <registry_address>/flux-image:latest \
  --name flux-schnell-app \
  --gpu 1 \
  --flavor ai1-1-gpu \
  --default-http-port 8188 \
  --volume flux-schnell@GRA/:/workspace/flux-model:RO \
  --env FLUX_VARIANT=base \
  --env BUCKET_MOUNT_PATH=/workspace/flux-model \
  --env UNET_FILE=flux1-schnell.safetensors \
  --env VAE_FILE=ae.safetensors \
  --env CLIP_FILE_1=clip_l.safetensors \
  --env CLIP_FILE_2=t5xxl_fp16.safetensors

Explication des paramètres

  • <registry_address>/flux-image:latest: l’image à déployer. Veillez à utiliser l’adresse de votre registre.
  • --name : définit le nom de l’app, flux_app ici.
  • --gpu : nombre de GPU demandés.
  • --flavor : le type de GPU demandé. Le code de flavor ai1-1-gpu correspond à un GPU V100S. Pour voir les autres GPU disponibles, exécutez ovhai capabilities flavor list. N’hésitez pas à changer le code de flavor pour un autre.
  • --default-http-port 8188 : port HTTP par défaut de l’app. ComfyUI écoute sur le port 8188.
  • --volume : monte les fichiers du modèle téléchargés depuis l’Object Storage. Dans ce cas, le conteneur flux-model est monté en lecture seule sur /workspace/flux-model.
  • --env : définit les variables d’environnement utilisées par entrypoint.sh pour configurer les liens symboliques vers les fichiers du modèle FLUX.
Warning

D’autres variantes FLUX peuvent attendre des fichiers dans des dossiers différents. Si vous prévoyez d’utiliser une autre variante, veillez également à mettre à jour les variables d’environnement en conséquence, et à ajuster le script entrypoint.sh si nécessaire pour correspondre aux nouveaux fichiers et structures de dossiers.

Une fois l’app lancée, AI Deploy exécutera les phases suivantes :

  • Phase de récupération de l’image : télécharge l’image Docker depuis votre registre.
  • Phase de synchronisation des données : monte le volume Object Storage et rend les fichiers du modèle disponibles.
  • Phase d’exécution : démarre le container, exécute votre entrypoint.sh, et lance l’interface ComfyUI.

Pour suivre la progression de votre app et ses logs en temps réel, utilisez :

ovhai app logs -f <app_id>

Une fois que vous voyez dans les logs que ComfyUI a démarré et écoute sur le port 8188, l’app est prête à l’emploi. Vous pouvez accéder à l’interface via l’URL publique fournie par la plateforme, telle que :

https://<app_id>.app.gra.ai.cloud.ovh.net

Vous pouvez la retrouver à tout moment à l’aide des commandes suivantes :

ovhai app list
ovhai app get <app_id>

Effectuer de l’inférence avec ComfyUI

Une fois dans l’interface web de ComfyUI, rendez-vous sur la page officielle des exemples ComfyUI FLUX. Trouvez l’image correspondant à votre variante déployée.

Ensuite, glissez-déposez cette image dans votre interface ComfyUI. Cela chargera automatiquement le workflow d’image FLUX.

Vous pouvez maintenant personnaliser le prompt textuel ou les paramètres selon vos besoins. Ensuite, cliquez simplement sur le bouton Run pour démarrer le processus de génération ou d’édition d’image.

Une fois l’image générée, vous pouvez la visualiser et la télécharger directement depuis le nœud de sortie de ComfyUI.

Aller plus loin

Si vous souhaitez déployer une interface différente telle qu’AUTOMATIC1111 avec Stable Diffusion XL, nous avons un guide pas à pas pour déployer cette WebUI populaire sur AI Deploy.

Si les concepts de génération d’images vous intéressent, vous pouvez apprendre le fonctionnement des réseaux de génération d’images et entraîner votre propre réseau antagoniste génératif (GAN). Consultez ce guide AI Notebooks : Créer et entraîner un modèle de génération d’images.

Pour une formation ou une assistance technique sur la mise en œuvre de nos solutions, contactez votre commercial ou consultez la page Professional Services pour obtenir un devis et faire analyser votre projet par nos experts.

Votre avis nous intéresse !

N’hésitez pas à nous faire part de vos questions, retours et suggestions pour améliorer le service :

Cette page vous a-t-elle aidé ?