Déployer un serveur MLflow dans un Codespace Github

Voici toutes les étapes pour lancer un serveur MLflow directement dans une machine virtuelle GitHub Codespace. Le gros avantage de cette méthode est quelle permet de lancer rapidement et gratuitement un serveur MLflow pour suivre vos expériences de machine learning. Voici le dépôt GitHub dont vous aurez besoin :

Lancer un serveur MLflow dans un codespace (GitHub)

Les codespaces sont des environnements de développement hébergés sur GitHub. Ils offrent un environnement de développement ou que vous soyez, depuis votre navigateur.

🚀 Partie 1 : Lancer un serveur MLflow dans codespace

Vous avez besoin d'un serveur MLflow hébergé gratuitement ? Suivez les étapes suivantes.

1. Dupliquez (fork) ce dépôt

Dupliquez (fork) le dépôt suivant : Lancer un serveur MLflow dans un codespace (GitHub)

2. Renseignez les variables d'environnement

Allez à la page de configuration des variables d'environnement pour Codespaces du dépôt, à l'adresse suivante : https://github.com/[votre-nom-utilisateur]/mlflow-server-devcontainer/settings/secrets/codespaces. Renseignez les variables suivantes :

• ARTIFACT_STORE_URI : L'URI de stockage des artéfacts (Amazon S3).
• AWS_ACCESS_KEY_ID et AWS_SECRET_ACCESS_KEY : Les identifiants de connexion à l'espace de stockage Amazon S3.
• BACKEND_STORE_URI : L'URI de votre base de donnée. Pour une base de donnée PostgreSQL, l'URI se présente au format : postgresql://[username]:[password]@[host]:[port]/[database]

Plus de renseignements sur la configuration d'un serveur de tracking MLflow : Set up the MLflow Tracking Environment.

3. Lancez un nouveau codespace

Lancez un nouveau codespace à partir de votre dépôt (UI de GitHub: Code / Codespaces / +)

4. Ouvrez le port 5001

Dans le Terminal, onglet "Ports", définissez l'URL du port 5001 comme public.

5. Accédez à l'UI MLflow

Accéder à l'UI MLflow en accédant à l'URL public exposée par codespace.

Utilisez cette URL pour le tracking de vos travaux de machine learning depuis un notebook Colab ou notebook local, soit en définissant la variable d'environnement MLFLOW_TRACKING_URI, soit en exécutant le code Python suivant dans votre notebook :

mlflow.set_tracking_uri(uri="http://<host>:<port>")

6. (Optionnel) Testez votre serveur MLflow

A l'intérieur de votre codespace, exécutez les étapes suivantes :

1. Entrainez un modèle : python3 demo/train.py. Vous devez voir apparaître un nouveau run dans l'UI MLflow et dans le Terminal.
2. Copiez le numéro de Run : Copiez le numéro de run (run id) qui apparaît dans le Terminal.
3. Utilisez un modèle : python3 demo/try-model.py. Entrez le numero de run (run id) dans le Terminal. Cette commande retourne un modèle dans le Terminal, cela signifie que vos modèle trackés par votre serveur MLflow sont disponibles à l'utilisation.

7. Utilisation depuis un notebook Colab

Démonstration de l'utilisation du serveur de tracking depuis ce notebook :

• Modifiez les variables d'environnement suivantes dans l'onglet "🔑 Secrets" :
  • MLFLOW_TRACKING_URI
  • AWS_ACCESS_KEY_ID
  • AWS_SECRET_ACCESS_KEY

Votre serveur MLflow fonctionne maintenant depuis votre codespace et vous pouvez trackez vos expériences de machine learning. N'oubliez pas de lancer et d'éteindre votre codespace à chaque utilisation. Sans quoi, du temps d'utilisation vous sera décompté.

Partie 2 : Comment ça marche ?

Si vous souhaitez simplement et rapidement lancer un serveur MLflow dans un codespace, seule la première partie de cet article vous est utile. Cette deuxième partie n'est utile que si vous souhaitez comprendre comment fonctionne la configuration d'un conteneur de développement (Dev Container) dans un codespace.

Les machines virtuelles codespace sont en réalité des conteneurs de développement (Dev Container), basés sur des images Docker. Pour créer notre serveur MLflow personnalisé qui fonctionne dans un codespace, nous avons créé une configuration de conteneur de développement (Dev Container) à partir d'une image Docker et d'un docker-compose.yaml.

Configuration d'un conteneur de développement

Pour configurer un conteneur de développement (Dev Container), nous créons les fichiers suivants :

• Un dossier .devcontainer/ : dossier de stockage de tous les fichiers de configuration du codespace.
• un fichier devcontainer.json : stocke les paramètres spécifiques à notre conteneur de développement (Dev container).
• un fichier Dockerfile : la configuration de l'image Docker qui configure le conteneur de développement avec les logiciels Python 3.10, Docker et GIT.
• un fichier docker-compose.yaml (Docker Compose) : permet de construire l'image Docker à partir du Dockerfile et de configurer les variables d'environnement dans le conteneur
• un fichier requirements.txt : permet d'installer les bibliothèques Python
• un fichier .dockerignore : permet d'ignorer certains dossier qu'on souhaite ignorer dans l'image finale.

Passons en revue les différents fichiers de configuration.

devcontainer.json

C'est le fichier principal de configuration du conteneur de développement. Il permet de :

• Créer un environnement de développement à partir du fichier docker-compose.yaml. Le paramètre "dockerComposeFile" indique le chemin vers le fichier docker-compose.yaml (qui lui-même utilise le Dockerfile). "service" indique quel service dans le fichier docker-compose.yaml doit être utilisé comme conteneur principal pour le codespace. "workspaceFolder" indique le dossier principal de travail à ouvrir dans le codespace.
• Rediriger le port sur lequel le serveur écoute, c-à-d 5001 pour notre cas avec le paramètre "forwardPorts". Le paramètre "onAutoForward": "openBrowser" indique au conteneur d'ouvrir l'URL public sur le port 5001 à chaque lancement du codespace.
• Ajouter des "features" avec le paramètre "features": Les "features" permettent d'ajouter rapidement et facilement davantage d’outils supplémentaires à notre conteneur de développement. Ici , nous avons ajouté Git et Docker (Docker est inutile pour notre cas d'utilisation).
• Personnaliser VS Code à l'intérieur du codespace "customizations": installer des extensions et customiser la présentation.

{
    "name": "MLflow Server",
    "dockerComposeFile": "../docker-compose.yaml",
    "service": "mlflow-server",
    "workspaceFolder": "/mlflow",

    // Use 'forwardPorts' to make a list of ports inside the container available locally.
    "forwardPorts": [5001],

    "portsAttributes": {
        "5001": {
            "label": "MLflow server port",
            "onAutoForward": "openBrowser"
        }
    },

    // Features to add to the dev container. More info: https://containers.dev/features.
    "features": {
        "ghcr.io/devcontainers/features/docker-in-docker:2": {},
        "ghcr.io/devcontainers/features/git:1": {}
    },

    // VS Code customization inside the container
    "customizations": {
        "vscode": {
            "settings": {
                "workbench.colorTheme": "Default Dark Modern"
            },
            "extensions": [
                "ms-vscode-remote.vscode-remote-extensionpack",
                "ms-azuretools.vscode-docker",
                "ms-python.vscode-pylance",
                "ms-python.python",
                "ms-vscode-remote.remote-containers",
                "GitHub.codespaces",
                "ms-toolsai.jupyter",
                "bierner.markdown-preview-github-styles"
            ]
        }
    }
}

Dockerfile

Le reste de la configuration est un peu plus simple. Nous créons une image docker avec un Dockerfile à partir d'une image Python 3.10, dans laquelle nous installons MLflow, Boto3, Psycopg et Scikit-learn avec le fichier requirements.txt. Puis nous lançons le serveur MLflow en utilisant les variables d'environnement du conteneur, définies dans le docker-compose.yaml.

FROM python:3.10-slim

WORKDIR /mlflow/mlflow-data

RUN python -m pip install --upgrade pip

COPY requirements.txt .

RUN pip install -r requirements.txt

CMD mlflow server --port $PORT --host 0.0.0.0 --backend-store-uri $BACKEND_STORE_URI --default-artifact-root $ARTIFACT_STORE_URI

Docker Compose (compose.yaml)

Enfin, nous créons un conteneur à partir de l'image définie dans le Dockerfile (build : .). Nous exposons le port 5001. Nous définissons les variables d'environnement qui provienne des réglages des secrets du codespace.

version: '3'
services:
  mlflow-server:
    build : .
    ports:
      - "5001:5001"
    environment:
      - PORT=5001
      - BACKEND_STORE_URI=$BACKEND_STORE_URI
      - ARTIFACT_STORE_URI=$ARTIFACT_STORE_URI
      - AWS_ACCESS_KEY_ID=$AWS_ACCESS_KEY_ID
      - AWS_SECRET_ACCESS_KEY=$AWS_SECRET_ACCESS_KEY
    volumes:
      - .:/mlflow
    restart: always

Et voilà ! Vous savez maintenant configurez votre propre conteneur de développement avec les outils et "features" dont vous avez besoin !

📃 Documentation

• Introduction to dev containers
• Create a Dev Container
• Dev Containers - Using Images, Dockerfiles, and Docker Compose
• Dev Container Features reference
• Available Dev Container Features
• Documentation Codespaces
• MLflow remote server