Déployer un serveur MLflow dans un Codespace Github
Tags: tutorial, python, devops, ai
Published: 2024-03-20 11:42:36

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)](https://github.com/DavidScanu/mlflow-server-devcontainer)

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)](https://github.com/DavidScanu/mlflow-server-devcontainer)

### 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](https://mlflow.org/docs/latest/tracking.html#set-up-the-mlflow-tracking-environment).

![Variables d'environnement pour Codespaces](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/p66zrbe5j4mc3qt0ocsw.png)

### 3. Lancez un nouveau codespace

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

![Lancez un nouveau codespace](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/6xsoqd8ngr8wetvsd0so.png)

### 4. Ouvrez le port 5001

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

![Ouvrez le port 5001](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/3f67dt2nynqx87yh9gag.png)

### 5. Accédez à l'UI MLflow

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

![Accédez à l'UI MLflow](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/qw4oicdm97y4byqrwt2d.png)

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 : 

```python
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.

![Testez votre serveur MLflow](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/vsb09mej1guppiyb6zcc.png)

### 7. Utilisation depuis un notebook Colab

Démonstration de l'utilisation du serveur de tracking depuis ce notebook : [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1sHlb9vpEj3y-v1rtHJ-5TaC-sTXii1D0?usp=sharing)

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

![Utilisation depuis un notebook Colab](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/sotwsn6vj2phkkdnyw80.png)

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.

```json
{
	"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`.

```docker
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.

```docker
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](https://docs.github.com/en/codespaces/setting-up-your-project-for-codespaces/adding-a-dev-container-configuration/introduction-to-dev-containers)
- [Create a Dev Container](https://code.visualstudio.com/docs/devcontainers/create-dev-container)
- [Dev Containers - Using Images, Dockerfiles, and Docker Compose](https://containers.dev/guide/dockerfile)
- [Dev Container Features reference](https://containers.dev/implementors/features/)
- [Available Dev Container Features](https://containers.dev/features)
- [Documentation Codespaces](https://docs.github.com/fr/codespaces)
- [MLflow remote server](https://mlflow.org/docs/latest/tracking/tutorials/remote-server.html)