Guide de déploiement

MLflow sur VPS : suivi d'expériences ML et registre de modèles

Déployer sur un VPS Cloud →

Tutoriel

MLflow sur VPS : suivi d'expériences ML et registre de modèles

Intelligence Artificielle6 min de lecture4 étapes

Un projet de machine learning produit vite des dizaines d'essais : un taux d'apprentissage changé ici, un jeu de données nettoyé là, et une métrique notée dans un coin de notebook. Trois semaines plus tard, personne ne sait plus quel modèle était le plus précis, ni avec quel code. MLflow est la plateforme open source (licence Apache-2.0) qui range tout cela sur un serveur central : paramètres, métriques et fichiers de chaque exécution, modèles versionnés, et traces des applications LLM. Ce guide l'installe sur un VPS avec Docker Compose, le protège par mot de passe, y branche votre code Python, puis règle les comptes, la sauvegarde et les mises à jour.

Sommaire· Pourquoi un serveur MLflow1/12
  1. 01Pourquoi un serveur MLflow
  2. 02Ce que MLflow apporte
  3. 03MLflow face au suivi à la main
  4. 04Prérequis
  5. 05Installer MLflow avec Docker Compose
  6. 06Sans --app-name basic-auth, le serveur est ouvert
  7. 07Envoyer vos expériences depuis Python
  8. 08Tracer une application LLM
  9. 09Le registre de modèles
  10. 10Comptes et permissions
  11. 11Sauvegarde et mise à jour
  12. 12Installation en 1 clic avec ServOrbit

Pourquoi un serveur MLflow

Lancé en local, MLflow écrit ses résultats dans un dossier mlruns sur votre poste : personne d'autre ne les voit, et ils disparaissent avec la machine. Un serveur de suivi change la donne. Chaque notebook, chaque script d'entraînement et chaque membre de l'équipe envoie ses exécutions au même endroit, et l'interface les compare côte à côte.

Le même serveur porte le registre de modèles — la liste des modèles validés, versionnés, avec un alias pour celui qui est en production — et, pour l'IA générative, les traces de vos appels aux modèles de langage.

Ce que MLflow apporte

  • Suivi d'expériences — paramètres, métriques et artefacts de chaque exécution, filtrés et comparés dans l'interface.
  • Registre de modèles — versions, alias et historique, pour savoir exactement ce qui tourne en production.
  • Traçage LLM — entrées, sorties, latence et étapes de chaque requête de vos applications d'IA générative.
  • Artefacts servis par le serveur — fichiers, graphiques et modèles envoyés en HTTPS, sans stockage S3 à configurer.
  • Journalisation automatique — autolog() pour scikit-learn, PyTorch, Transformers, XGBoost, OpenAI ou LangChain.
  • Comptes et permissions — un compte par personne, des droits donnés expérience par expérience.

MLflow face au suivi à la main

Faites défiler le tableau

Serveur MLflowNotebooks et tableur
Historique des essaisChaque exécution enregistrée automatiquementCe qu'on a pensé à noter
Comparer deux modèlesUn écran, métriques côte à côteRecopier des chiffres
Fichiers produitsRangés avec l'exécution qui les a créésDispersés sur les postes
Modèle en productionUne version et un alias dans le registreUn fichier nommé « final_v3 »
Travail en équipeUn serveur partagé, des comptesDes envois de fichiers

Prérequis

Un VPS Ubuntu 24.04 avec 2 Go de RAM suffit pour démarrer ; prévoyez 4 Go et davantage de disque si vous stockez beaucoup de modèles, car ce sont les artefacts qui occupent la place. Il vous faut Docker avec le plugin Compose, et un nom de domaine pointant vers le VPS, avec nginx et un certificat HTTPS : vos scripts et votre équipe s'y connecteront.

Installer MLflow avec Docker Compose

  1. Préparer le répertoire et les secrets

    Créez le répertoire de l'application et un fichier .env qui porte le mot de passe du compte admin, la clé de session et votre domaine.

    mkdir -p /opt/mlflow && cd /opt/mlflow
    cat > .env <<EOF
    ADMIN_PASSWORD=$(openssl rand -hex 16)
    SECRET_KEY=$(openssl rand -hex 24)
    DOMAIN=mlflow.example.ma
    EOF
    chmod 600 .env
  2. Écrire le docker-compose.yml

    L'image -full est la variante officielle qui embarque le module d'authentification. Au démarrage, la commande écrit le fichier basic_auth.ini qui déclare le compte admin ; --allowed-hosts n'accepte que votre domaine et la boucle locale. Le port n'est publié que sur la boucle locale : seul nginx y accède. MLFLOW_SERVER_ENABLE_JOB_EXECUTION=false coupe l'exécuteur de tâches de fond, gourmand en mémoire et inutile au suivi.

    services:
      mlflow:
        image: ghcr.io/mlflow/mlflow:v3.18.0-full
        restart: unless-stopped
        ports:
          - "127.0.0.1:5000:5000"
        environment:
          ADMIN_PASSWORD: ${ADMIN_PASSWORD}
          DOMAIN: ${DOMAIN}
          MLFLOW_FLASK_SERVER_SECRET_KEY: ${SECRET_KEY}
          MLFLOW_AUTH_CONFIG_PATH: /mlflow/basic_auth.ini
          MLFLOW_SERVER_ENABLE_JOB_EXECUTION: "false"
        entrypoint: ["/bin/sh", "-c"]
        command:
          - >-
            mkdir -p /mlflow/artifacts &&
            printf '[mlflow]\ndefault_permission = NO_PERMISSIONS\ndatabase_uri = sqlite:////mlflow/basic_auth.db\nadmin_username = admin\nadmin_password = %s\nauthorization_function = mlflow.server.auth:authenticate_request_basic_auth\n' "$$ADMIN_PASSWORD" > /mlflow/basic_auth.ini &&
            exec mlflow server --app-name basic-auth --host 0.0.0.0 --port 5000 --workers 2
            --backend-store-uri sqlite:////mlflow/mlflow.db --artifacts-destination /mlflow/artifacts
            --allowed-hosts "$$DOMAIN,localhost:*,127.0.0.1:*"
        volumes:
          - mlflow-data:/mlflow
    
    volumes:
      mlflow-data: {}
  3. Démarrer et vérifier

    Le démarrage prend une quinzaine de secondes. /health répond sans authentification ; l'API, elle, renvoie 401 sans identifiants.

    docker compose up -d
    curl -fsS http://127.0.0.1:5000/health
    curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:5000/api/2.0/mlflow/experiments/search
  4. Publier en HTTPS avec nginx

    Dans le vhost de votre domaine (certificat obtenu par certbot), proxifiez vers le port local en transmettant l'en-tête Host. Relevez client_max_body_size : un modèle envoyé comme artefact dépasse vite la limite par défaut.

    location / {
        proxy_pass http://127.0.0.1:5000;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-Proto $scheme;
        client_max_body_size 512m;
    }

Sans --app-name basic-auth, le serveur est ouvert

Par défaut, mlflow server n'a aucune authentification : quiconque atteint l'adresse peut lire vos expériences, télécharger vos modèles et tout supprimer. Gardez --app-name basic-auth, ne publiez jamais le port 5000 sur l'IP publique, et laissez --allowed-hosts à votre seul domaine : c'est la protection de MLflow contre le DNS rebinding.

Envoyer vos expériences depuis Python

Installez le client (pip install mlflow) sur le poste ou le serveur d'entraînement, puis pointez-le vers votre serveur. Les identifiants se passent par variables d'environnement :

import os
import mlflow

os.environ["MLFLOW_TRACKING_USERNAME"] = "admin"
os.environ["MLFLOW_TRACKING_PASSWORD"] = "VOTRE_MOT_DE_PASSE"
mlflow.set_tracking_uri("https://mlflow.example.ma")
mlflow.set_experiment("churn-model")

with mlflow.start_run():
    mlflow.log_param("learning_rate", 0.01)
    mlflow.log_metric("accuracy", 0.93)
    mlflow.log_artifact("confusion_matrix.png")

L'exécution apparaît aussitôt dans l'interface, avec ses paramètres, ses métriques et le fichier envoyé. mlflow.sklearn.autolog() ou mlflow.pytorch.autolog() enregistrent tout cela sans une ligne de plus.

Tracer une application LLM

Pour un assistant ou un agent, le traçage enregistre chaque requête avec ses appels au modèle, ses étapes et leur durée. Activez la journalisation automatique de votre bibliothèque, ou décorez vos propres fonctions :

import mlflow

mlflow.set_experiment("support-assistant")
mlflow.openai.autolog()   # chaque appel au client OpenAI devient une trace

@mlflow.trace
def answer(question: str) -> str:
    ...

Les traces s'affichent dans l'onglet de l'expérience : vous voyez quel appel a été lent, quel contexte a été envoyé et ce que le modèle a répondu.

Le registre de modèles

Quand un essai est validé, enregistrez son modèle dans le registre : il reçoit un numéro de version, et vous pouvez lui donner un alias comme production.

mlflow.register_model(f"runs:/{run_id}/model", "churn-model")

Votre service d'inférence charge alors models:/churn-model@production : changer de modèle revient à déplacer l'alias, sans toucher au code.

Comptes et permissions

Le compte admin crée les autres comptes par l'API :

curl -u admin:VOTRE_MOT_DE_PASSE -X POST https://mlflow.example.ma/api/2.0/mlflow/users/create \
  -H 'Content-Type: application/json' \
  -d '{"username": "sara", "password": "UN_MOT_DE_PASSE_LONG"}'

Un nouveau compte ne voit aucune expérience tant qu'on ne lui en a pas partagé : les droits (lecture, édition, gestion) se donnent expérience par expérience et modèle par modèle. Changez le mot de passe admin par l'API users/update-password (en fournissant l'ancien dans current_password) ; le nouveau est conservé aux redémarrages.

Sauvegarde et mise à jour

Tout l'état de MLflow tient dans le volume mlflow-data : la base des expériences, celle des comptes et le dossier des artefacts. Sauvegardez-le conteneur arrêté, puis copiez l'archive hors du VPS :

cd /opt/mlflow
docker compose stop
docker run --rm -v mlflow_mlflow-data:/data -v "$PWD":/backup alpine \
  tar czf /backup/mlflow-$(date +%F).tar.gz -C /data .
docker compose start

Pour mettre à jour, lisez d'abord les notes de version — une mise à jour peut migrer le schéma de la base —, changez le tag de l'image dans docker-compose.yml, puis :

cd /opt/mlflow
docker compose pull && docker compose up -d
docker compose logs --tail 20

Installation en 1 clic avec ServOrbit

Les Applications en 1 clic de ServOrbit installent MLflow sur votre VPS sans ligne de commande : il déploie le conteneur officiel, génère le mot de passe du compte admin et la clé de session, active l'authentification sur l'interface et l'API, limite les noms d'hôte acceptés à votre adresse et publie le serveur en HTTPS sur un sous-domaine de votre domaine ou sur le sous-domaine gratuit du VPS (mlflow.{dns_slug}.servorbit-dns.com). Le mot de passe s'affiche dans votre espace client ; il ne reste qu'à brancher vos notebooks.

Vos expériences ML sur votre propre serveur

Un VPS ServOrbit Ubuntu 24.04 avec 2 Go de RAM suffit pour démarrer MLflow. Installation en 1 clic depuis votre espace client, HTTPS sur votre domaine ou sur le sous-domaine gratuit du VPS, mot de passe généré pour vous.

Besoin d'aide ?

Parcourez notre centre d'aide et notre FAQ, ou contactez notre équipe — rappel, WhatsApp ou e-mail. Support en français, anglais et arabe.

Écrire sur WhatsApps'ouvre dans un nouvel onglet