Aller au contenu principal
Dernière mise à jour le

Link Production Traces to App Versions

Le guide suivre les versions de l’application a montré comment suivre les versions de l’application à l’aide de LoggedModel pendant le développement.

Lors du déploiement d’un LoggedModel en production, vous devez link les traces générées à la version spécifique pour le monitoring et le debugging. Ce guide montre comment configurer votre déploiement pour inclure des informations de version dans les traces de production.

astuce

Déploiement sur Apps ou Model Serving La liaison de traces est automatiquement configurée pour vous. Passez à la liaison de traces sur Databricks pour plus de détails.

Prérequis​

  1. Pour les déploiements en production en dehors de Databricks Model Serving , installez le package mlflow-tracing :

    Bash
    pip install --upgrade "mlflow-tracing>=3.1.0"

    Ce package est spécifiquement optimisé pour les environnements de production et offre :

    • Dépendances minimales pour des déploiements plus rapides et plus légers
    • Optimisations des performances pour le suivi à haut volume
remarque

MLflow 3 est requis pour le traçage en production. MLflow 2.x n’est pas pris en charge pour les déploiements en production en raison de limitations de performances et de fonctionnalités manquantes pour une utilisation en production.

  1. Créez une Experimentation MLflow en suivant le guide de démarrage rapide de configuration de votre environnement.

Configuration des variables d’environnement​

  1. Accédez à l’onglet tab pour obtenir l’ID LoggedModel. Dans votre pipeline CI/CD, vous pouvez générer un nouveau LoggedModel en utilisant create_external_model() et en lisant l’attribut model_id de l’objet renvoyé, comme indiqué ci-dessous.
Python
import mlflow
import subprocess

# Define your application and its version identifier
app_name = "customer_support_agent"

# Get current git commit hash for versioning
try:
    git_commit = (
        subprocess.check_output(["git", "rev-parse", "HEAD"])
        .decode("ascii")
        .strip()[:8]
    )
    version_identifier = f"git-{git_commit}"
except subprocess.CalledProcessError:
    version_identifier = "local-dev"  # Fallback if not in a git repo

logged_model_name = f"{app_name}-{version_identifier}"

# Create a new LoggedModel
model = mlflow.create_external_model(name=logged_model_name)

# Capture the generated LoggedModel ID, for example "m-9dcd3a2b8e764e5bb4e8a89b4e4c6f21".
# This is the value your deployment needs, not logged_model_name.
print(model.model_id)
  1. Ajoutez l'ID LoggedModel à la configuration de votre environnement de production dans la variable d'environnement MLFLOW_ACTIVE_MODEL_ID, parallèlement aux variables de traçage MLflow standard issues du guide de démarrage rapide de configuration de votre environnement.
important

MLFLOW_ACTIVE_MODEL_ID n’accepte que l’ID LoggedModel généré, qui start avec m-. MLflow enregistre cette valeur sur chaque trace telle quelle et ne résout jamais un nom LoggedModel à partir de celle-ci. Si vous le définissez sur un nom, vos traces ne sont pas liées à la version que vous aviez prévue. Seul mlflow.set_active_model() accepte un nom.

Bash
# Standard MLflow tracing configuration
export DATABRICKS_HOST="https://your-workspace.databricks.com"
export DATABRICKS_TOKEN="your-databricks-token"
export MLFLOW_TRACKING_URI=databricks
# Either use MLFLOW_EXPERIMENT_NAME or MLFLOW_EXPERIMENT_ID
export MLFLOW_EXPERIMENT_NAME="/Shared/production-genai-app"

# Add LoggedModel version tracking by specifying your generated LoggedModel ID
# Ensure this matches a LoggedModel in your MLflow experiment
export MLFLOW_ACTIVE_MODEL_ID="m-9dcd3a2b8e764e5bb4e8a89b4e4c6f21"

Liaison automatique des traces​

important

Lorsque vous définissez la variable d’environnement MLFLOW_ACTIVE_MODEL_ID, toutes les traces sont automatiquement liées à ce LoggedModel . Vous n’avez pas besoin de taguer manuellement les traces : MLflow s’en charge pour vous !

Votre code d'application reste exactement le même que lors du développement :

Python
import mlflow
from fastapi import FastAPI, Request

app = FastAPI()

@mlflow.trace
def process_message(message: str) -> str:
    # Your actual application logic here
    # This is just a placeholder
    return f"Processed: {message}"

@app.post("/chat")
def handle_chat(request: Request, message: str):
    # Your traces are automatically linked to the LoggedModel
    # specified in MLFLOW_ACTIVE_MODEL_ID

    # Your application logic here
    response = process_message(message)
    return {"response": response}

Pour ajouter un contexte supplémentaire à vos traces (telles que des identifiants utilisateur, des identifiants de session ou des métadonnées personnalisées), consultez Ajouter un contexte aux traces dans le guide de traçage de production.

Exemples de déploiement​

Docker​

Lors du déploiement avec Docker, transmettez toutes les variables d’environnement nécessaires via la configuration de votre conteneur :

Dockerfile
# Dockerfile
FROM python:3.9-slim

# Install dependencies
COPY requirements.txt .
RUN pip install -r requirements.txt

# Copy application code
COPY . /app
WORKDIR /app

# Declare required environment variables (no defaults)
ENV DATABRICKS_HOST
ENV DATABRICKS_TOKEN
ENV MLFLOW_TRACKING_URI
ENV MLFLOW_EXPERIMENT_NAME
ENV MLFLOW_ACTIVE_MODEL_ID

CMD ["python", "app.py"]

Exécutez le conteneur avec des variables d’environnement :

Bash
docker run -d \
  -e DATABRICKS_HOST="https://your-workspace.databricks.com" \
  -e DATABRICKS_TOKEN="your-databricks-token" \
  -e MLFLOW_TRACKING_URI=databricks \
  -e MLFLOW_EXPERIMENT_NAME="/Shared/production-genai-app" \
  -e MLFLOW_ACTIVE_MODEL_ID="m-9dcd3a2b8e764e5bb4e8a89b4e4c6f21" \
  -e APP_VERSION="1.0.0" \
  your-app:latest

Kubernetes​

Pour les déploiements Kubernetes, utilisez des ConfigMaps et des Secrets pour gérer la configuration :

YAML
# configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: mlflow-config
data:
  DATABRICKS_HOST: 'https://your-workspace.databricks.com'
  MLFLOW_TRACKING_URI: 'databricks'
  MLFLOW_EXPERIMENT_NAME: '/Shared/production-genai-app'
  MLFLOW_ACTIVE_MODEL_ID: 'm-9dcd3a2b8e764e5bb4e8a89b4e4c6f21'

---
# secret.yaml
apiVersion: v1
kind: Secret
metadata:
  name: databricks-secrets
type: Opaque
stringData:
  DATABRICKS_TOKEN: 'your-databricks-token'

---
# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: genai-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: genai-app
  template:
    metadata:
      labels:
        app: genai-app
    spec:
      containers:
        - name: app
          image: your-app:latest
          ports:
            - containerPort: 8000
          envFrom:
            - configMapRef:
                name: mlflow-config
            - secretRef:
                name: databricks-secrets
          env:
            - name: APP_VERSION
              value: '1.0.0'
          resources:
            requests:
              memory: '256Mi'
              cpu: '250m'
            limits:
              memory: '512Mi'
              cpu: '500m'

Interrogation de traces spécifiques à une version​

Une fois déployé, vous pouvez afficher les traces dans l’interface utilisateur de suivi MLflow ou interroger les traces par version de modèle dans le SDK :

Python
import mlflow

# Get the experiment ID
experiment = mlflow.get_experiment_by_name("/Shared/production-genai-app")

# Find all traces from a specific model version.
# model_id must be the generated LoggedModel ID, the same value you set in
# MLFLOW_ACTIVE_MODEL_ID. Passing a LoggedModel name here does not find the
# traces belonging to that version.
traces = mlflow.search_traces(
    experiment_ids=[experiment.experiment_id],
    model_id="m-9dcd3a2b8e764e5bb4e8a89b4e4c6f21",
)

# View the results
print(f"Found {len(traces)} traces for this model version")

Liaison des traces sur Databricks Apps et Model Serving​

Lorsque vous déployez sur des applications et que MLflow 3 est installé dans votre environnement de développement, la liaison des traces est configurée automatiquement.

Pour afficher les traces de votre endpoint Databricks Model Serving :

  1. Accédez à l'Expérimentation MLflow qui était active lorsque vous avez appelé agents.deploy()
  2. Cliquez sur l’onglet Traces pour afficher les traces
  3. Toutes les traces sont automatiquement liées à la version spécifique du modèle qui sert les requêtes

La seule exigence est que le code de votre application utilise le suivi MLflow (soit via l’enregistrement automatique, soit via une instrumentation manuelle avec @mlflow.trace).

Interface utilisateur des traces de production

Étapes suivantes​

Pour une configuration complète du suivi de production incluant l’authentification, le monitoring et la collecte de commentaires pour les déploiements en dehors de Databricks Model Serving, consultez Observabilité de la production avec le suivi.

Sur cette page