> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/premiers-pas/docker-images.md).

# Images Docker

Images Docker prêtes à déployer pour les charges de travail IA sur Clore.ai

Images Docker prêtes à déployer pour des charges de travail IA sur CLORE.AI.

{% hint style="success" %}
Déployez ces images directement sur [la place de marché CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## Référence de déploiement rapide

### Les plus populaires

| Tâche                                   | Image                                | Ports     |
| --------------------------------------- | ------------------------------------ | --------- |
| Discuter avec l’IA                      | `ollama/ollama`                      | 22, 11434 |
| Interface de type ChatGPT               | `ghcr.io/open-webui/open-webui`      | 22, 8080  |
| Génération d’images                     | `universonic/stable-diffusion-webui` | 22, 7860  |
| Génération d’images basée sur des nœuds | `yanwk/comfyui-boot`                 | 22, 8188  |
| Serveur API LLM                         | `vllm/vllm-openai`                   | 22, 8000  |

***

## Modèles de langage

### Ollama

**Exécuteur LLM universel - la façon la plus simple d’exécuter n’importe quel modèle.**

```
Image : ollama/ollama
Ports : 22/tcp, 11434/http
Commande : ollama serve
```

**Après le déploiement :**

```bash
# Se connecter en SSH au serveur
ssh -p <port> root@<proxy>

# Récupérer et exécuter un modèle
ollama pull llama3.2
ollama run llama3.2
```

**Variables d'environnement :**

```
OLLAMA_HOST=0.0.0.0
OLLAMA_MODELS=/root/.ollama/models
```

***

### Open WebUI

**Interface de type ChatGPT pour Ollama.**

```
Image : ghcr.io/open-webui/open-webui:ollama
Ports : 22/tcp, 8080/http
```

Inclut Ollama intégré. Accès via le port HTTP.

**Autonome (connexion à un Ollama existant) :**

```
Image : ghcr.io/open-webui/open-webui:main
Ports : 22/tcp, 8080/http
Environnement : OLLAMA_BASE_URL=http://localhost:11434
```

***

### vLLM

**Serveur LLM haute performance avec API compatible OpenAI.**

```
Image : vllm/vllm-openai:latest
Ports : 22/tcp, 8000/http
Commande : python -m vllm.entrypoints.openai.api_server --model meta-llama/Meta-Llama-3.1-8B-Instruct --host 0.0.0.0
```

**Pour les modèles plus volumineux (multi-GPU) :**

```bash
python -m vllm.entrypoints.openai.api_server \\
    --model meta-llama/Meta-Llama-3.1-70B-Instruct \\
    --tensor-parallel-size 2 \
    --host 0.0.0.0
```

**Variables d'environnement :**

```
HUGGING_FACE_HUB_TOKEN=<your-token>  # Pour les modèles soumis à restriction
```

***

### Text Generation Inference (TGI)

**Serveur LLM de production de HuggingFace.**

```
Image : ghcr.io/huggingface/text-generation-inference:latest
Ports : 22/tcp, 8080/http
Commande : --model-id meta-llama/Meta-Llama-3.1-8B-Instruct
```

**Variables d'environnement :**

```
HUGGING_FACE_HUB_TOKEN=<your-token>
MAX_INPUT_LENGTH=4096
MAX_TOTAL_TOKENS=8192
```

***

## Génération d’images

### Stable Diffusion WebUI (AUTOMATIC1111)

**Interface SD la plus populaire avec extensions.**

```
Image : universonic/stable-diffusion-webui:latest
Ports : 22/tcp, 7860/http
```

**Pour une faible VRAM (8 Go ou moins) :**

```bash
./webui.sh --listen --medvram --xformers
```

**Pour l’accès à l’API :**

```bash
./webui.sh --listen --xformers --api
```

***

### ComfyUI

**Flux de travail basé sur des nœuds pour les utilisateurs avancés.**

```
Image : yanwk/comfyui-boot:cu130-slim
Ports : 22/tcp, 8188/http
Environnement : CLI_ARGS=--listen 0.0.0.0
```

**Images alternatives :**

```
# Avec les extensions courantes
Image : yanwk/comfyui-boot:cu130-megapak-pt211

# Minimal
Image : pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
```

**Commande d’installation manuelle :**

```bash
git clone https://github.com/comfyanonymous/ComfyUI && cd ComfyUI && pip install -r requirements.txt && python main.py --listen 0.0.0.0
```

***

### Fooocus

**Interface SD simplifiée, de type Midjourney.**

```
Image : pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
Ports : 22/tcp, 7865/http
Commande : git clone https://github.com/lllyasviel/Fooocus && cd Fooocus && pip install -r requirements.txt && python launch.py --listen
```

***

### FLUX

**Dernière génération d’images de haute qualité.**

Utilisez ComfyUI avec les nœuds FLUX :

```
Image : yanwk/comfyui-boot:cu130-slim
Ports : 22/tcp, 8188/http
```

Ou via Diffusers :

```
Image : pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
Ports : 22/tcp
```

```python
# Après SSH
pip install diffusers transformers accelerate
python << 'EOF'
from diffusers import FluxPipeline
pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell")
pipe.enable_model_cpu_offload()
image = pipe("A cat", num_inference_steps=4).images[0]
image.save("output.png")
EOF
```

***

## Génération vidéo

### Stable Video Diffusion

```
Image : pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
Ports : 22/tcp
```

```bash
pip install diffusers transformers accelerate
python << 'EOF'
from diffusers import StableVideoDiffusionPipeline
from diffusers.utils import load_image, export_to_video
pipe = StableVideoDiffusionPipeline.from_pretrained(
    "stabilityai/stable-video-diffusion-img2vid-xt",
    variant="fp16"
)
pipe.to("cuda")
image = load_image("input.png")
frames = pipe(image, num_frames=25).frames[0]
export_to_video(frames, "output.mp4", fps=7)
EOF
```

***

### AnimateDiff

À utiliser avec ComfyUI :

```
Image : yanwk/comfyui-boot:cu130-slim
Ports : 22/tcp, 8188/http
```

Installez les nœuds AnimateDiff via ComfyUI Manager.

***

## Audio et voix

### Whisper (transcription)

```
Image : onerahmet/openai-whisper-asr-webservice:latest
Ports : 22/tcp, 9000/http
Environnement : ASR_MODEL=large-v3
```

**Utilisation de l’API :**

```bash
curl -X POST "http://localhost:9000/asr" \\
    -F "audio_file=@audio.mp3" \\
    -F "task=transcribe"
```

***

### Bark (synthèse vocale)

```
Image : pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
Ports : 22/tcp
```

```bash
pip install bark
python << 'EOF'
from bark import SAMPLE_RATE, generate_audio, preload_models
from scipy.io.wavfile import write as write_wav
preload_models()
audio = generate_audio("Hello, this is a test.")
write_wav("output.wav", SAMPLE_RATE, audio)
EOF
```

***

### Stable Audio

```
Image : pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
Ports : 22/tcp
```

```bash
pip install stable-audio-tools
# Nécessite un jeton HF pour accéder au modèle
```

***

## Modèles de vision

### LLaVA

```
Image : pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
Ports : 22/tcp
```

```bash
pip install llava
python -m llava.serve.cli --model-path liuhaotian/llava-v1.6-34b
```

***

### Llama 3.2 Vision

Utilisez Ollama :

```
Image : ollama/ollama
Ports : 22/tcp, 11434/http
```

```bash
ollama pull llama3.2-vision
ollama run llama3.2-vision "describe this image" --images photo.jpg
```

***

## Développement et entraînement

### Base PyTorch

**Pour des configurations personnalisées et l’entraînement.**

```
Image : pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
Ports : 22/tcp
```

Inclut : CUDA 12.8, cuDNN 9, PyTorch 2.11

***

### Jupyter Lab

**Carnets interactifs pour le ML.**

```
Image : quay.io/jupyter/pytorch-notebook:cuda12-pytorch-2.11.0
Ports : 22/tcp, 8888/http
```

Ou utilisez la base PyTorch avec Jupyter :

```bash
pip install jupyterlab
jupyter lab --ip=0.0.0.0 --allow-root --no-browser
```

***

### Entraînement Kohya

**Pour LoRA et le fine-tuning des modèles.**

```
Image : pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
Ports : 22/tcp
```

```bash
git clone https://github.com/kohya-ss/sd-scripts
cd sd-scripts
pip install -r requirements.txt
# Utiliser les scripts d’entraînement
```

***

## Référence des images de base

{% hint style="danger" %}
**Faites correspondre la version CUDA à la carte.** La série RTX 50 (Blackwell) nécessite CUDA 12.8+ et PyTorch 2.7+ ; une image CUDA 12.4 échoue dessus avec `aucune image noyau n’est disponible pour l’exécution sur le périphérique`. Matrice complète : [Compatibilité CUDA et PyTorch](/guides/guides_v2-fr/premiers-pas/cuda-pytorch-compatibility.md).
{% endhint %}

### Officiel NVIDIA

| Image                                    | CUDA | Cas d’utilisation                                     |
| ---------------------------------------- | ---- | ----------------------------------------------------- |
| `nvidia/cuda:12.8.1-devel-ubuntu22.04`   | 12.8 | Développement CUDA, fonctionne de Turing à Blackwell  |
| `nvidia/cuda:12.8.1-runtime-ubuntu22.04` | 12.8 | CUDA runtime uniquement                               |
| `nvidia/cuda:13.0.3-devel-ubuntu24.04`   | 13.0 | La plus récente ; uniquement Turing et plus récent    |
| `nvidia/cuda:11.8.0-devel-ubuntu22.04`   | 11.8 | Cartes héritées (Pascal, anciennes générations Volta) |

### Officiel PyTorch

| Image                                          | PyTorch | CUDA | Cartes                                              |
| ---------------------------------------------- | ------- | ---- | --------------------------------------------------- |
| `pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel` | 2.11    | 12.8 | **Par défaut.** Ampere, Ada, Blackwell              |
| `pytorch/pytorch:2.13.0-cuda13.2-cudnn9-devel` | 2.13    | 13.2 | Turing et plus récent                               |
| `pytorch/pytorch:2.10.0-cuda12.8-cudnn9-devel` | 2.10    | 12.8 | Dernière version avec prise en charge de Tesla V100 |
| `pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel`  | 2.5     | 12.4 | Cartes de minage Pascal                             |

### HuggingFace

| Image                                           | Objectif               |
| ----------------------------------------------- | ---------------------- |
| `huggingface/transformers-pytorch-gpu`          | Transformers + PyTorch |
| `ghcr.io/huggingface/text-generation-inference` | Serveur TGI            |

***

## Variables d’environnement

### Variables courantes

| Variable                 | Description                                        | Exemple        |
| ------------------------ | -------------------------------------------------- | -------------- |
| `HUGGING_FACE_HUB_TOKEN` | Jeton API HF pour les modèles soumis à restriction | `hf_xxx`       |
| `CUDA_VISIBLE_DEVICES`   | Sélection du GPU                                   | `0,1`          |
| `TRANSFORMERS_CACHE`     | Répertoire du cache des modèles                    | `/root/.cache` |

### Variables Ollama

| Variable              | Description            | Par défaut         |
| --------------------- | ---------------------- | ------------------ |
| `OLLAMA_HOST`         | Adresse de liaison     | `127.0.0.1`        |
| `OLLAMA_MODELS`       | Répertoire des modèles | `~/.ollama/models` |
| `OLLAMA_NUM_PARALLEL` | Requêtes parallèles    | `1`                |

### Variables vLLM

| Variable                 | Description                          |
| ------------------------ | ------------------------------------ |
| `VLLM_ATTENTION_BACKEND` | Implémentation de l’attention        |
| `VLLM_USE_MODELSCOPE`    | Utiliser ModelScope à la place de HF |

***

## Référence des ports

| Port  | Protocole | Service                    |
| ----- | --------- | -------------------------- |
| 22    | TCP       | SSH                        |
| 7860  | HTTP      | Gradio (SD WebUI, Fooocus) |
| 7865  | HTTP      | Alternative à Fooocus      |
| 8000  | HTTP      | API vLLM                   |
| 8080  | HTTP      | Open WebUI, TGI            |
| 8188  | HTTP      | ComfyUI                    |
| 8888  | HTTP      | Jupyter                    |
| 9000  | HTTP      | API Whisper                |
| 11434 | TCP       | API Ollama                 |

***

## Conseils

### Stockage persistant

Montez des volumes pour conserver les données entre les redémarrages :

```bash
docker run -v /data/models:/root/.cache/huggingface ...
```

### Sélection des GPU

Pour les systèmes multi-GPU :

```bash
docker run --gpus '"device=0,1"' ...
# ou
CUDA_VISIBLE_DEVICES=0,1
```

### Gestion de la mémoire

Si la VRAM vient à manquer :

1. Utilisez des modèles plus petits
2. Activez le déchargement vers le CPU
3. Réduire la taille du lot
4. Utilisez des modèles quantifiés (GGUF Q4)

## Étapes suivantes

* [Comparaison des GPU](/guides/guides_v2-fr/premiers-pas/gpu-comparison.md) - Choisissez le bon GPU
* [Compatibilité des modèles](/guides/guides_v2-fr/premiers-pas/model-compatibility.md) - Ce qui fonctionne où
* [Guide de démarrage rapide](/guides/guides_v2-fr/quickstart.md) - Commencez en 5 minutes


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/premiers-pas/docker-images.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.