Plateforme de workflows Dify.ai

Déployez Dify.ai sur Clore.ai — créez des workflows IA prêts pour la production, des pipelines RAG et des applications d'agents avec une interface visuelle à des prix de cloud GPU.

Aperçu

Dify.ai est une plateforme open source de développement d'applications LLM avec 114 k+ étoiles GitHub. Elle combine un constructeur visuel de workflows, une chaîne de génération augmentée par récupération (RAG), l'orchestration d'agents, la gestion des modèles et une couche de déploiement d'API en un clic dans une seule pile auto-hébergeable.

Sur Clore.ai vous pouvez exécuter l'ensemble de la pile Dify — y compris sa base de données Postgres, le cache Redis, le magasin vectoriel Weaviate, le proxy inverse Nginx, les workers API et le frontend web — sur un serveur GPU loué pour aussi peu que 0,07–0,21 $/h (RTX 3090/4090). Le GPU est facultatif pour Dify lui-même, mais devient essentiel lorsque vous intégrez l'inférence locale de modèles via les backends Ollama ou vLLM.

Fonctionnalités clés :

🔄 Constructeur visuel de workflows — des pipelines LLM par glisser-déposer avec branchements, boucles et logique conditionnelle
📚 Pipeline RAG — importez des PDF, des URL, des pages Notion ; découpage + embeddings + récupération, le tout géré dans l'interface
🤖 Mode agent — agents ReAct et d'appel de fonctions avec utilisation d'outils (recherche web, interpréteur de code, API personnalisées)
🚀 Conçu pour l’API — chaque application génère instantanément un point de terminaison REST et des extraits de SDK
🔌 100+ intégrations de modèles — OpenAI, Anthropic, Mistral, Cohere, plus des modèles locaux via Ollama/vLLM
🏢 Multi-locataire — équipes, espaces de travail, RBAC, quotas d'utilisation

Exigences

Les configurations multi-GPU de classe 80 Go ne sont pas répertoriées sur la place de marché Clore.ai. Les plus grosses machines répertoriées aujourd’hui sont 4× RTX PRO 6000 Blackwell (96 Go chacune, 380 Go au total) et 8–11× RTX 5090 (32 Go chacune). La capacité A100 / H200 / B200 est proposée en bare metal sur demande. Consultez bare metal sur demande. Consultez Tarifs et disponibilité des GPU avant de dimensionner un déploiement.

Dify s'exécute sous forme d'une pile Docker Compose multi-conteneurs. Le serveur minimum viable pour le développement est une instance CPU uniquement ; pour la production avec inférence locale de modèles, vous voudrez un nœud GPU.

Configuration

GPU

VRAM

RAM système

Disque

Prix Clore.ai

Minime (clés API uniquement)

Aucun / CPU

—

8 Go

30 Go

~0,05 $/h (CPU)

Standard

RTX 3080

10 Go

16 Go

50 Go

0,05–0,19 $/h

Recommandé

RTX 3090 / 4090

24 Go

32 Go

80 Go

0,07–0,21 $/h

Production + LLM local

A100 80 Go

80 Go

64 Go

200 Go

bare metal

Haute capacité de traitement

H100 SXM

80 Go

128 Go

500 Go

~1,04 $/h

Astuce : Si vous n'utilisez que des fournisseurs d'API cloud (OpenAI, Anthropic, etc.), toute instance CPU à 2 cœurs avec 8 Go de RAM fonctionne. Un GPU n'est utile que lorsque vous exécutez des modèles locaux via Ollama ou vLLM — voir Accélération GPU ci-dessous.

Remarque sur le stockage

Les données Weaviate et Postgres augmentent rapidement avec les importations de documents. Prévoir au moins 50 Go et monter un stockage persistant via les options de volume de Clore.ai.

Démarrage rapide

1. Louez un serveur Clore.ai

Accédez à clore.ai, filtrez selon le GPU souhaité et déployez un serveur avec :

Docker préinstallé (toutes les images Clore l'incluent)
Ports exposés 80 et 443 (ajoutez des ports personnalisés dans les paramètres de l'offre si nécessaire)
Accès SSH activé

2. Connectez-vous et préparez le serveur

# Connectez-vous en SSH à votre serveur Clore
ssh root@<clore-server-ip> -p <ssh-port>

# Mettez à jour les paquets système
apt-get update && apt-get upgrade -y

# Vérifiez que Docker est disponible
docker --version
docker compose version   # Doit être v2.x

3. Clonez Dify et lancez-le

# Cloner le dépôt
git clone https://github.com/langgenius/dify.git
cd dify/docker

# Copiez le fichier d'environnement d'exemple
cp .env.example .env

# (Facultatif) Modifiez les paramètres avant le lancement
nano .env

# Récupérez toutes les images et démarrez tous les services en arrière-plan
docker compose up -d

# Surveillez les journaux pendant le démarrage (prend 2 à 3 minutes lors du premier lancement)
docker compose logs -f

4. Vérifiez que tous les services sont opérationnels

# Vérifiez l'état des conteneurs
docker compose ps

# Sortie attendue :
# NOM                     STATUT
# docker-api-1            En cours d'exécution (sain)
# docker-web-1            En cours d'exécution (sain)
# docker-worker-1         En cours d'exécution (sain)
# docker-nginx-1          En cours d'exécution
# docker-db-1             En cours d'exécution (sain)
# docker-redis-1          En cours d'exécution (sain)
# docker-weaviate-1       En cours d'exécution (sain)
# docker-sandbox-1        En cours d'exécution (sain)

5. Accédez à l'interface web

Ouvrez votre navigateur et allez à :

http://<clore-server-ip>:80

Au premier lancement, Dify vous redirigera vers l'assistant de configuration pour créer le compte administrateur. Terminez l'assistant, puis connectez-vous.

Configuration

Toute la configuration se trouve dans dify/docker/.env. Voici les paramètres les plus importants :

Variables d'environnement essentielles

# ── Clés secrètes (MODIFIEZ-LES) ──────────────────────────────────────────────
SECRET_KEY=votre-clé-super-secrète-modifiez-la-immédiatement
# Générez une clé forte :
# python3 -c "import secrets; print(secrets.token_hex(32))"

# ── URL de l'application ─────────────────────────────────────────────────────
# Définissez-la sur l'IP publique ou le domaine de votre serveur
CONSOLE_WEB_URL=http://<clore-server-ip>
APP_WEB_URL=http://<clore-server-ip>

# ── Base de données (Postgres) ───────────────────────────────────────────────
DB_USERNAME=postgres
DB_PASSWORD=difyai123456          # À changer en production !
DB_HOST=db
DB_PORT=5432
DB_DATABASE=dify

# ── Redis ───────────────────────────────────────────────────────────────────
REDIS_HOST=redis
REDIS_PORT=6379
REDIS_PASSWORD=difyai123456       # À changer en production !

# ── Stockage (disque local par défaut) ───────────────────────────────────────
STORAGE_TYPE=local
# Ou utilisez un stockage compatible S3 :
# STORAGE_TYPE=s3
# S3_ENDPOINT=https://s3.amazonaws.com
# S3_BUCKET_NAME=votre-bucket-dify
# S3_ACCESS_KEY=...
# S3_SECRET_KEY=...

# ── Fournisseur LLM par défaut ───────────────────────────────────────────────
# Définissez-le dans l'interface après connexion, ou préconfigurez-le ici :
# OPENAI_API_KEY=sk-...

Changer le port exposé

Par défaut, Nginx écoute sur le port 80. Pour le changer :

# Dans docker-compose.yaml, modifiez le service nginx :
# ports :
#   - "8080:80"   ← remplacez 8080 par le port hôte de votre choix

# Puis redémarrez :
docker compose down && docker compose up -d

Volumes de données persistants

Le fichier Compose de Dify monte ces volumes par défaut :

volumes:
  oradata :          # Données Postgres
  redis_data :       # AOF Redis
  weaviate_data :    # Magasin vectoriel
  app_storage :      # Documents importés et fichiers générés

Pour sauvegarder :

# Arrêtez d'abord les services, puis archivez les volumes Docker
docker compose stop
docker run --rm \
  -v docker_oradata:/data \
  -v $(pwd)/backups:/backup \
  alpine tar czf /backup/postgres-$(date +%Y%m%d).tar.gz /data
docker compose start

Accélération GPU

La plateforme principale de Dify repose sur le CPU, mais vous débloquez l'inférence locale des modèles en intégrant Ollama ou vLLM comme fournisseurs de modèles — les deux bénéficient énormément d'un GPU.

Option A : sidecar Ollama (le plus simple)

Exécutez Ollama aux côtés de Dify sur le même serveur Clore :

# Installer Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Téléchargez un modèle (par ex. Llama 3 8B)
ollama pull llama3:8b

# Vérifiez que le GPU est utilisé
ollama run llama3:8b "Hello!"
nvidia-smi   # Doit montrer le processus ollama utilisant la VRAM

Puis dans l'interface Dify → Paramètres → Fournisseurs de modèles → Ollama:

URL de base : http://localhost:11434
Sélectionnez votre modèle et enregistrez

Pour un guide complet Ollama, voir language-models/ollama.md.

Option B : sidecar vLLM (haute capacité)

# Exécutez vLLM comme conteneur séparé avec passage du GPU
docker run -d \
  --name vllm \
  --gpus all \
  --runtime nvidia \
  -p 8000:8000 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  -e HUGGING_FACE_HUB_TOKEN=<votre-token-hf> \
  vllm/vllm-openai:latest \
  --model mistralai/Mistral-7B-Instruct-v0.2 \
  --dtype auto \
  --max-model-len 4096

# Vérifiez le point de terminaison
curl http://localhost:8000/v1/models

Puis dans l'interface Dify → Paramètres → Fournisseurs de modèles → Compatible OpenAI:

URL de base : http://localhost:8000/v1
Clé API : dummy
Nom du modèle : mistralai/Mistral-7B-Instruct-v0.2

Pour la configuration complète de vLLM, voir language-models/vllm.md.

Recommandations de mémoire GPU pour les modèles locaux

Modèle

VRAM requise

GPU Clore recommandé

Llama 3 8B (Q4)

6 Go

RTX 3060

Llama 3 8B (FP16)

16 Go

RTX 3090 / 4090

Mistral 7B (Q4)

5 Go

RTX 3060

Llama 3 70B (Q4)

40 Go

A100 40 Go

Llama 3 70B (FP16)

140 Go

2× H100

Conseils et bonnes pratiques

Optimisation des coûts sur Clore.ai

# Utilisez la tarification spot — les bases de données de Dify conservent l'état dans les volumes
# vous pouvez donc arrêter/redémarrer l'instance à moindre coût

# Avant d'arrêter votre instance Clore, exportez la base de données :
docker exec docker-db-1 pg_dump -U postgres dify > dify_backup_$(date +%Y%m%d).sql

# Compressez le volume de stockage pour le transfert
tar czf dify_storage_$(date +%Y%m%d).tar.gz \
  $(docker volume inspect docker_app_storage --format '{{.Mountpoint}}')

Activez HTTPS avec Caddy (recommandé pour la production)

# Ajoutez Caddy à docker-compose.yaml ou exécutez-le séparément
docker run -d \
  --name caddy \
  --network docker_default \
  -p 443:443 -p 80:80 \
  -v $PWD/Caddyfile:/etc/caddy/Caddyfile \
  -v caddy_data:/data \
  caddy:latest

# Contenu du Caddyfile :
# votre-domaine.com {
#     reverse_proxy nginx:80
# }

Mettez à l'échelle les workers pour les charges lourdes

# Lancez 4 workers celery au lieu de 1
docker compose up -d --scale worker=4

Surveillez l'utilisation des ressources

# Statistiques des conteneurs en direct
docker stats

# Utilisation du GPU (si vous utilisez des modèles locaux)
watch -n1 nvidia-smi

# Journaux de l'application Dify
docker compose logs -f api worker

Optimisation des performances RAG

Définissez taille des segments à 512–1024 jetons pour la plupart des types de documents
Activer récupération parent-enfant pour les longs documents dans les paramètres du jeu de données
Utilisez recherche hybride (mot-clé + vecteur) pour un meilleur rappel sur le contenu technique
Indexez les documents en dehors des heures de pointe pour éviter les limites de débit de l'API

Dépannage

Les services redémarrent sans cesse

# Vérifiez les journaux du service en échec
docker compose logs --tail=50 api
docker compose logs --tail=50 worker

# Cause fréquente : SECRET_KEY incorrecte ou connexion à la base de données
# Assurez-vous que SECRET_KEY dans .env est définie et unique
grep SECRET_KEY .env

"La migration a échoué" au démarrage

# Exécutez manuellement les migrations de la base de données
docker compose exec api flask db upgrade

# Si cela échoue, vérifiez d'abord que Postgres est sain
docker compose exec db pg_isready -U postgres

Impossible de se connecter à Ollama depuis Dify

# Par défaut, Ollama se lie à 127.0.0.1
# Modifiez-le pour écouter sur toutes les interfaces :
OLLAMA_HOST=0.0.0.0 ollama serve

# Ou modifiez le service systemd :
systemctl edit ollama
# Ajoutez sous [Service] :
# Environment="OLLAMA_HOST=0.0.0.0"
systemctl restart ollama

# Testez depuis un conteneur Dify :
docker compose exec api curl http://host.docker.internal:11434/api/tags

Plus d'espace disque

# Vérifiez la taille des volumes
df -h
docker system df

# Supprimez les images inutilisées
docker image prune -a

# Les journaux Weaviate peuvent devenir volumineux — faites-les tourner
docker compose exec weaviate truncate -s 0 /tmp/weaviate.log

Erreurs du magasin vectoriel Weaviate

# Réinitialisez Weaviate (AVERTISSEMENT : supprime tous les embeddings, ré-indexation nécessaire)
docker compose stop weaviate
docker volume rm docker_weaviate_data
docker compose up -d weaviate

# Puis ré-indexez vos jeux de données dans l'interface Dify → Jeux de données → [jeu de données] → Réindexer

Le port 80 est déjà utilisé

# Trouvez ce qui utilise le port 80
ss -tlnp | grep :80
# ou
lsof -i :80

# Arrêtez le service en conflit ou changez le port nginx de Dify dans docker-compose.yaml

Pour aller plus loin

PrécédentAperçu

SuivantWorkflows IA n8n

Mis à jour il y a 1 mois

Ce contenu vous a-t-il été utile ?