Accueil » Actualités » Données & IA » MLflow : suivre, versionner et gouverner vos modèles d’IA en open source
Logo de MLflow — MLflow : suivre, versionner et gouverner vos modèles d’IA en open source

MLflow : suivre, versionner et gouverner vos modèles d’IA en open source

Quel jeu de données, quels paramètres et quelle version du code ont produit le modèle de scoring actuellement en production ? Dans beaucoup d’organisations, la réponse dort dans un tableur, un notebook oublié ou la mémoire d’un data scientist parti depuis. Ce manque de traçabilité freine la mise en production, complique les audits et devient un vrai sujet de conformité avec la montée des exigences sur les systèmes d’IA. MLflow répond à ce problème : c’est une plateforme open source qui centralise le suivi des expériences, le registre des modèles et, depuis la version 3, l’observabilité des applications à base de LLM. Que vous ayez une petite équipe data ou plusieurs dizaines de projets d’IA répartis entre directions métiers, il fournit un point de vérité unique que la DSI peut héberger, sécuriser et superviser.

Qu’est-ce que MLflow ?

MLflow est un projet open source publié sous licence Apache 2.0 et développé sur GitHub (dépôt mlflow/mlflow). La version stable la plus récente au moment de la rédaction est la 3.18.0, publiée début novembre 2026. La plateforme couvre deux grands volets :

  • Entraînement de modèles : suivi des expériences (paramètres, métriques, artefacts de chaque exécution, appelée « run »), évaluation des modèles, registre de modèles (Model Registry) avec gestion des versions, et déploiement.

  • LLM et agents : traçage (tracing) des appels aux modèles avec prise en charge native d’OpenTelemetry, évaluation de la qualité des réponses, registre et optimisation des prompts, et une passerelle AI Gateway pour encadrer l’accès aux fournisseurs de modèles.

Les API clientes sont disponibles en Python, TypeScript/JavaScript et Java, et le serveur expose une API REST utilisable depuis n’importe quel langage. Concrètement, MLflow s’intègre directement dans les scripts d’entraînement et les notebooks Jupyter que vos équipes utilisent déjà.

Architecture et fonctionnement

Une installation MLflow repose sur quatre briques :

  • Le client : la bibliothèque appelée dans le code (mlflow.log_param, mlflow.log_metric, autologging des frameworks) qui envoie les informations au serveur.

  • Le serveur de suivi (tracking server) : il sert l’interface web et l’API. Par défaut, il écoute uniquement sur 127.0.0.1, port 5000.

  • Le backend store : la base qui stocke les métadonnées (expériences, runs, paramètres, métriques, registre). MLflow passe par SQLAlchemy et prend en charge SQLite, PostgreSQL, MySQL et SQL Server. Depuis MLflow 3.7, le stockage par défaut est un fichier SQLite (mlflow.db) ; l’ancien stockage en fichiers (./mlruns) est en mode maintenance et appelé à être déprécié.

  • L’artifact store : l’emplacement des fichiers volumineux (modèles sérialisés, graphiques, jeux de test), typiquement un stockage objet compatible S3.

Deux modes d’accès aux artefacts existent. En mode proxy (option –artifacts-destination), le serveur relaie les téléversements : les postes clients n’ont besoin d’aucun identifiant sur le stockage objet, ce qui simplifie la gestion des secrets. En mode direct (–no-serve-artifacts avec –default-artifact-root), les clients écrivent eux-mêmes dans le bucket, ce qui décharge le serveur mais suppose de distribuer des droits d’accès au stockage.

Installation

Pour un premier essai sur un poste ou une VM de test, une installation Python suffit. Le projet fournit aussi une pile Docker Compose de référence (MLflow, PostgreSQL et un stockage objet RustFS) dans le dossier docker-compose du dépôt officiel :

# Essai rapide (environnement virtuel Python)
python3 -m venv ~/venv-mlflow
source ~/venv-mlflow/bin/activate
pip install mlflow
mlflow server --port 5000
# Interface : http://localhost:5000 (métadonnées dans mlflow.db, SQLite)

# Pile de référence officielle : MLflow + PostgreSQL + RustFS
git clone https://github.com/mlflow/mlflow.git
cd mlflow/docker-compose
cp .env.dev.example .env
docker compose up -d

Déploiement en production : base de données, stockage et authentification

La documentation officielle est explicite : le serveur intégré n’est ni authentifié ni chiffré par défaut. Avant d’ouvrir MLflow à plusieurs équipes, quatre points sont à traiter.

  • Une vraie base de données : SQLite convient à un test, pas à un usage partagé. Utilisez PostgreSQL ou MySQL, et lancez la commande mlflow db upgrade pour mettre le schéma à jour avant chaque démarrage après une montée de version. Le registre de modèles exige d’ailleurs un backend en base de données.

  • Un stockage objet : bucket S3 ou stockage compatible S3 hébergé en interne, avec le serveur en mode proxy pour éviter de distribuer des clés d’accès.

  • L’authentification : MLflow propose une authentification HTTP basique intégrée (paquet mlflow[auth], option –app-name basic-auth). Aucun mot de passe administrateur n’est fourni par défaut : le compte admin est créé au premier démarrage à partir de la variable MLFLOW_AUTH_ADMIN_PASSWORD (12 caractères minimum), et le serveur refuse de démarrer sans elle. Les droits passent par des rôles (depuis MLflow 3.13) avec les niveaux READ, USE, EDIT, MANAGE et NO_PERMISSIONS ; le niveau par défaut est READ, à abaisser si les expériences contiennent des données sensibles. La documentation mentionne aussi le SSO et des plugins d’authentification personnalisés : dans une organisation dotée d’un fournisseur d’identité comme authentik ou Entra ID, c’est la voie à privilégier pour éviter des comptes locaux supplémentaires.

  • Le chiffrement et l’exposition : placez le serveur derrière un reverse proxy (NGINX, Apache, Traefik…) qui porte le certificat TLS, et utilisez les options de sécurité –allowed-hosts et –cors-allowed-origins (disponibles depuis la version 3.5) pour limiter les noms d’hôte et origines acceptés.

Pour les plateformes conteneurisées, un chart Helm officiel est publié au format OCI sur ghcr.io ; sa version suit celle de MLflow. Il gère la configuration de la base via un Secret Kubernetes, le stockage S3, le TLS, l’Ingress, une tâche de nettoyage planifiée et l’exposition de métriques Prometheus. Exemple de déploiement autonome puis sur Kubernetes, et configuration côté client :

# Serveur de production : métadonnées dans PostgreSQL, artefacts sur S3
pip install 'mlflow[auth]' psycopg2 boto3
export AWS_ACCESS_KEY_ID="<clé du compte de service S3>"
export AWS_SECRET_ACCESS_KEY="<secret>"
export MLFLOW_FLASK_SERVER_SECRET_KEY="<clé aléatoire, identique sur tous les serveurs>"
export MLFLOW_AUTH_ADMIN_PASSWORD="<mot de passe de 12 caractères minimum>"

mlflow db upgrade postgresql://mlflow:<mdp>@db.interne:5432/mlflowdb
mlflow server \
  --app-name basic-auth \
  --backend-store-uri postgresql://mlflow:<mdp>@db.interne:5432/mlflowdb \
  --artifacts-destination s3://mlflow-artefacts \
  --host 0.0.0.0 --port 5000 \
  --allowed-hosts "mlflow.entreprise.fr"

# Kubernetes : chart Helm officiel (version du chart = version de MLflow)
helm install mlflow oci://ghcr.io/mlflow/charts/mlflow \
  --version <version> --namespace mlflow --create-namespace
helm show values oci://ghcr.io/mlflow/charts/mlflow --version <version>

# Poste client (script d'entraînement ou notebook)
export MLFLOW_TRACKING_URI=https://mlflow.entreprise.fr
export MLFLOW_TRACKING_USERNAME=jdupont
export MLFLOW_TRACKING_PASSWORD="<mot de passe>"

# Exemple Python
import mlflow
mlflow.set_experiment("detection-fraude")
with mlflow.start_run():
    mlflow.log_param("max_depth", 6)
    mlflow.log_metric("auc", 0.91)
    mlflow.log_artifact("matrice_confusion.png")

Usage au quotidien

Une fois le serveur en place, chaque exécution d’entraînement enregistre ses paramètres, métriques et artefacts. L’interface web permet de comparer les runs côte à côte, de filtrer par métrique et de retrouver exactement la configuration d’un modèle donné. Les fonctions d’autologging capturent automatiquement ces informations pour les principales bibliothèques (scikit-learn, PyTorch, XGBoost, etc.), ce qui limite les modifications de code.

Le registre de modèles joue le rôle de catalogue officiel : chaque modèle enregistré reçoit des versions successives, et les équipes de production référencent une version précise plutôt qu’un fichier copié à la main. C’est aussi la pièce qui facilite les audits : on remonte de la version déployée au run, puis aux paramètres et aux données utilisés.

Côté IA générative, le tracing enregistre chaque appel à un LLM (prompt, réponse, latence, outils appelés par un agent). Il fonctionne aussi bien avec des API commerciales qu’avec des modèles hébergés en interne, par exemple via Ollama et son API compatible OpenAI, ce qui permet de garder prompts et réponses sur votre infrastructure.

MLflow face aux alternatives

  • Weights & Biases : plateforme commerciale très complète pour le suivi d’expériences, surtout utilisée en SaaS. MLflow l’emporte quand la souveraineté des données et l’auto-hébergement priment.

  • Kubeflow : plateforme MLOps native Kubernetes, centrée sur l’orchestration de pipelines. Plus lourde à opérer, elle est souvent complémentaire de MLflow plutôt que concurrente.

  • DVC : versionnement des données et des modèles s’appuyant sur Git. Il répond à la traçabilité des jeux de données, là où MLflow suit les exécutions et le cycle de vie des modèles ; les deux se combinent bien.

  • Langfuse : outil open source spécialisé dans l’observabilité des applications LLM. Pertinent si vous ne faites que de l’IA générative ; MLflow a l’avantage de couvrir aussi le machine learning classique dans un seul outil.

Bonnes pratiques

  • Dimensionner selon votre structure : pour une petite équipe, une VM avec PostgreSQL, un bucket S3 et un reverse proxy TLS suffit largement. Pour une grande entreprise, préférez le chart Helm sur Kubernetes, une base PostgreSQL en haute disponibilité, un stockage objet répliqué et l’option workspaces (–enable-workspaces, backend SQL requis) pour cloisonner les directions ou les projets.

  • Centraliser l’identité : pas de serveur exposé sans authentification ; reliez MLflow à votre fournisseur d’identité (SSO) et appliquez le moindre privilège via les rôles.

  • Sauvegarder les deux stockages : la base de métadonnées et le bucket d’artefacts doivent être sauvegardés ensemble, faute de quoi le registre pointe vers des fichiers absents. Sauvegardez la base avant chaque mlflow db upgrade.

  • Superviser et journaliser : collectez les métriques exposées avec Prometheus et envoyez les journaux du reverse proxy vers votre SIEM pour tracer les accès aux modèles.

  • Maîtriser les données : artefacts et traces LLM peuvent contenir des données personnelles ou confidentielles ; définissez des durées de conservation et un nettoyage régulier des runs supprimés.

Conclusion

MLflow apporte ce qui manque souvent aux projets d’IA en entreprise : une traçabilité complète, du run d’entraînement au modèle déployé, et désormais jusqu’aux appels des applications LLM. Open source, auto-hébergeable et pris en charge par un chart Helm officiel, il s’adapte aussi bien à une équipe de quelques personnes qu’à une plateforme mutualisée pour tout un groupe. Commencez par un serveur de test, puis industrialisez avec PostgreSQL, un stockage objet, le SSO et une supervision en place.

À lire aussi : Open WebUI : une interface IA auto-hébergée pour vos LLM · Valkey : la base clé-valeur en mémoire open source issue de Redis

Partagez cet article !
Défiler vers le haut