MLOps Fundamentals : les 9 étapes clés pour passer de zéro à opérationnel

scikit-learn==1.4.0
xgboost==2.0.3
pandas==2.1.4
numpy==1.26.3
mlflow==2.10.0
dvc==3.38.1
fastapi==0.109.0
uvicorn==0.27.0
pydantic==2.5.3
evidently==0.4.16
pytest==7.4.4
pytest-cov==4.1.0
httpx==0.26.0
joblib==1.3.2
matplotlib==3.8.2
seaborn==0.13.1
imbalanced-learn==0.11.0

__pycache__/
*.pyc
*.pyo
.env
models/
mlruns/
*.pkl
data/raw/
data/processed/
monitoring/reports/*.html
monitoring/reports/*.json
.coverage
htmlcov/

"""Génère un dataset synthétique de fraude carte de crédit."""
import pandas as pd
import numpy as np

def generate_fraud_dataset(n_samples=50000, fraud_ratio=0.002, random_state=42):
    np.random.seed(random_state)
    n_fraud = int(n_samples * fraud_ratio)
    n_legit = n_samples - n_fraud

    legit = pd.DataFrame({
        f'V{i}': np.random.normal(0, 1, n_legit) for i in range(1, 29)
    })
    legit['Amount'] = np.abs(np.random.exponential(scale=88, size=n_legit))
    legit['Time'] = np.sort(np.random.uniform(0, 172800, n_legit))
    legit['Class'] = 0

    fraud = pd.DataFrame({
        f'V{i}': np.random.normal(np.random.uniform(-3, 3), 2, n_fraud) for i in range(1, 29)
    })
    fraud['Amount'] = np.abs(np.random.exponential(scale=122, size=n_fraud))
    fraud['Time'] = np.random.uniform(0, 172800, n_fraud)
    fraud['Class'] = 1

    df = pd.concat([legit, fraud], ignore_index=True)
    df = df.sample(frac=1, random_state=random_state).reset_index(drop=True)
    return df

if __name__ == "__main__":
    df = generate_fraud_dataset()
    df.to_csv("data/raw/creditcard.csv", index=False)
    print(f"Dataset généré : {len(df)} lignes")
    print(f"Fraudes : {df['Class'].sum()} ({df['Class'].mean()*100:.3f}%)")

wine-classifier/
â└â─â─ Dockerfile              # Notre fichier de configuration Docker
â└â─â─ .dockerignore           # Fichiers à exclure de l'image
â└â─â─ requirements.txt        # Dépendances Python
â└â─â─ src/
â├â─â─   app.py               # Application FastAPI (point d'entrée)
â├â─â─   predict.py           # Logique de prédiction
â├â─â─   preprocessing.py     # Pré-traitement des features
â└â─â─ models/
    â└â─â─ rf_classifier.pkl   # Modèle Random Forest sérialisé
    â└â─â─ scaler.pkl           # StandardScaler sauvegardé

# requirements.txt
# Framework web
fastapi==0.110.0
uvicorn[standard]==0.27.1

# Machine Learning
scikit-learn==1.4.1
numpy==1.26.4
pandas==2.2.1

# Sérialisation du modèle
joblib==1.3.2

# Validation des données
pydantic==2.6.3

# src/app.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import joblib
import numpy as np
import os

app = FastAPI(
    title="Wine Quality Classifier API",
    description="API de classification de la qualité du vin basée sur Random Forest",
    version="1.0.0"
)

# Chargement du modèle au démarrage (pas à chaque requête)
MODEL_PATH = os.getenv("MODEL_PATH", "/app/models/rf_classifier.pkl")
SCALER_PATH = os.getenv("SCALER_PATH", "/app/models/scaler.pkl")

model = joblib.load(MODEL_PATH)
scaler = joblib.load(SCALER_PATH)

class WineFeatures(BaseModel):
    fixed_acidity: float
    volatile_acidity: float
    citric_acid: float
    residual_sugar: float
    chlorides: float
    free_sulfur_dioxide: float
    total_sulfur_dioxide: float
    density: float
    pH: float
    sulphates: float
    alcohol: float

@app.get("/health")
def health_check():
    return {"status": "ok", "model": "rf_classifier", "version": "1.0.0"}

@app.post("/predict")
def predict(features: WineFeatures):
    try:
        X = np.array([[
            features.fixed_acidity, features.volatile_acidity,
            features.citric_acid, features.residual_sugar,
            features.chlorides, features.free_sulfur_dioxide,
            features.total_sulfur_dioxide, features.density,
            features.pH, features.sulphates, features.alcohol
        ]])
        X_scaled = scaler.transform(X)
        prediction = model.predict(X_scaled)[0]
        probability = model.predict_proba(X_scaled)[0].max()
        return {
            "quality": int(prediction),
            "confidence": round(float(probability), 4),
            "label": "bon vin" if prediction >= 6 else "vin moyen"
        }
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

# ============================================================
# Dockerfile pour un modèle scikit-learn servi avec FastAPI
# ============================================================

# Étape 1 : Image de base
FROM python:3.11-slim

# Étape 2 : Métadonnées de l'image
LABEL maintainer="mlops-team@exemple.com"
LABEL version="1.0.0"
LABEL description="Wine Quality Classifier - Random Forest API"

# Étape 3 : Variables d'environnement système
ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1 \
    PIP_NO_CACHE_DIR=1 \
    PIP_DISABLE_PIP_VERSION_CHECK=1

# Étape 4 : Répertoire de travail dans le conteneur
WORKDIR /app

# Étape 5 : Dépendances système (si nécessaire)
RUN apt-get update && apt-get install -y --no-install-recommends \
    libgomp1 \
    && rm -rf /var/lib/apt/lists/*

# Étape 6 : Copier ET installer les dépendances Python (couche cachée)
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Étape 7 : Copier le code source
COPY src/ ./src/

# Étape 8 : Copier le modèle ML
COPY models/ ./models/

# Étape 9 : Exposer le port de l'API
EXPOSE 8000

# Étape 10 : Utilisateur non-root pour la sécurité
RUN useradd --create-home --shell /bin/bash appuser
USER appuser

# Étape 11 : Commande de démarrage
CMD ["uvicorn", "src.app:app", "--host", "0.0.0.0", "--port", "8000"]

ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1 \
    PIP_NO_CACHE_DIR=1 \
    PIP_DISABLE_PIP_VERSION_CHECK=1

# .dockerignore pour un projet ML

# Contrôle de version
.git/
.gitignore
.github/

# Environnements Python virtuels (critique ! peut faire des centaines de Mo)
.venv/
venv/
env/
ENV/
__pycache__/
*.py[cod]
*.pyo
.pytest_cache/
.mypy_cache/

# Données ML (ne jamais embarquer dans l'image !)
data/
datasets/
*.csv
*.parquet
*.arrow
*.feather

# Notebooks Jupyter (pas nécessaires en production)
*.ipynb
.ipynb_checkpoints/

# Fichiers de configuration locale
.env
.env.local
.env.development
*.env

# Documentation et tests (inutiles en production)
docs/
tests/
README.md
CHANGELOG.md

# Artefacts de build
dist/
build/
*.egg-info/
htmlcov/
.coverage

# IDE et éditeurs
.vscode/
.idea/
*.swp
*.swo
.DS_Store
Thumbs.db

# Logs et fichiers temporaires
logs/
*.log
tmp/
temp/

# Fichiers MLflow et expériences
mlruns/
mlflow.db

# Modèles de test (garder seulement le modèle de production)
models/experiments/
models/checkpoints/

# ============================================================
# Multi-stage Dockerfile pour Wine Classifier (production)
# ============================================================

# ---- ÉTAPE 1 : Builder ----
# Cette étape installe tout, y compris les outils de compilation
FROM python:3.11-slim AS builder

# Variables d'environnement pour le build
ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1 \
    PIP_NO_CACHE_DIR=1

WORKDIR /build

# Installer les outils de build système (ne seront PAS dans l'image finale)
RUN apt-get update && apt-get install -y --no-install-recommends \
    gcc \
    g++ \
    build-essential \
    libgomp1 \
    && rm -rf /var/lib/apt/lists/*

# Copier et installer dans un répertoire local isolé (--prefix)
COPY requirements.txt .
RUN pip install --no-cache-dir --prefix=/install -r requirements.txt


# ---- ÉTAPE 2 : Image de production (finale) ----
# Image finale ultra-légère : ne contient PAS gcc, build-essential, etc.
FROM python:3.11-slim AS production

ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1

WORKDIR /app

# Copier uniquement les bibliothèques installées depuis le builder
COPY --from=builder /install /usr/local

# Dépendances système runtime (minimales)
RUN apt-get update && apt-get install -y --no-install-recommends \
    libgomp1 \
    && rm -rf /var/lib/apt/lists/*

# Copier le code source et le modèle
COPY src/ ./src/
COPY models/ ./models/

# Sécurité : utilisateur non-root
RUN useradd --create-home --shell /bin/bash appuser && \
    chown -R appuser:appuser /app
USER appuser

EXPOSE 8000

CMD ["uvicorn", "src.app:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "2"]

# ============================================================
# Multi-stage Dockerfile avec étape de test intégrée
# ============================================================

FROM python:3.11-slim AS base
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 PIP_NO_CACHE_DIR=1
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt


# ---- Étape de test ----
FROM base AS test
COPY requirements-dev.txt .
RUN pip install --no-cache-dir -r requirements-dev.txt
COPY src/ ./src/
COPY models/ ./models/
COPY tests/ ./tests/
RUN pytest tests/ -v --tb=short


# ---- Étape de production ----
FROM base AS production
COPY src/ ./src/
COPY models/ ./models/
RUN useradd --create-home appuser && chown -R appuser /app
USER appuser
EXPOSE 8000
CMD ["uvicorn", "src.app:app", "--host", "0.0.0.0", "--port", "8000"]