Bagikan melalui

Menautkan Jejak Produksi ke Versi Aplikasi

Panduan melacak versi aplikasi menunjukkan cara melacak versi aplikasi menggunakan LoggedModel selama pengembangan.

Saat menyebarkan LoggedModel ke lingkungan produksi, Anda perlu mengaitkan trace yang dihasilkannya kembali ke versi tertentu untuk pemantauan dan debugging. Panduan ini menunjukkan cara mengonfigurasi penyebaran Anda untuk menyertakan informasi versi dalam jejak produksi.

Petunjuk / Saran

Menerapkan pada Databricks Model Serving? Penautan jejak dikonfigurasi secara otomatis untuk Anda. Lewati ke Penautan Jejak pada Pelayanan Model Databricks untuk detailnya.

Prasyarat

  1. Untuk penyebaran produksi di luar Databricks Model Serving, instal paket mlflow-tracing.

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

    Paket ini secara khusus dioptimalkan untuk lingkungan produksi, menawarkan:

    • Dependensi minimal untuk penyebaran yang lebih cepat dan lebih ramping
    • Pengoptimalan performa untuk pelacakan volume tinggi

    Nota

    MLflow 3 diperlukan untuk pelacakan produksi. MLflow 2.x tidak didukung untuk penyebaran produksi karena keterbatasan performa dan fitur yang hilang untuk penggunaan produksi.

  2. Buat eksperimen MLflow dengan mengikuti panduan mulai cepat untuk menyiapkan lingkungan Anda.

Konfigurasi Variabel Lingkungan

  1. Navigasi ke tab versi untuk mendapatkan LoggedModel ID. Di alur CI/CD, Anda dapat menghasilkan LoggedModel baru dengan menggunakan create_external_model() seperti yang ditunjukkan di bawah ini. Kami menyarankan untuk menggunakan
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)
  1. Tambahkan ID LoggedModel ke konfigurasi lingkungan produksi Anda dalam variabel lingkungan MLFLOW_ACTIVE_MODEL_ID bersama dengan variabel pelacakan MLflow standar dari panduan memulai cepat untuk menyiapkan lingkungan Anda.
# 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 LoggedModel ID
# Ensure this matches a LoggedModel in your MLFlow Experiment
export MLFLOW_ACTIVE_MODEL_ID="customer_support_agent-git-98207f02"

Penautan Penjejakan Otomatis

Penting

Saat Anda mengatur MLFLOW_ACTIVE_MODEL_ID variabel lingkungan, semua jejak secara otomatis ditautkan ke LoggedModel tersebut. Anda tidak perlu menandai jejak secara manual - MLflow menangani ini untuk Anda!

Kode aplikasi Anda tetap sama persis seperti selama pengembangan:

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}

Untuk menambahkan konteks tambahan ke jejak Anda (seperti ID pengguna, ID sesi, atau metadata kustom), lihat Menambahkan konteks ke jejak produksi dalam panduan pelacakan produksi.

Contoh Penyebaran

Buruh kapal

Saat menyebarkan dengan Docker, teruskan semua variabel lingkungan yang diperlukan melalui konfigurasi kontainer Anda:

# 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"]

Jalankan kontainer dengan variabel lingkungan:

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="customer_support_agent-git-98207f02" \
  -e APP_VERSION="1.0.0" \
  your-app:latest

Kubernetes

Untuk penyebaran Kubernetes, gunakan ConfigMaps dan Secrets untuk mengelola konfigurasi:

# 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: 'customer_support_agent-git-98207f02'

---
# 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'

Mengkueri Jejak Version-Specific

Setelah disebarkan, Anda dapat melihat jejak di UI pelacakan MLflow atau Anda dapat mengkueri jejak berdasarkan versi model di SDK:

import mlflow

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

# Find all traces from a specific model version
traces = mlflow.search_traces(
    experiment_ids=[experiment.experiment_id],
    model_id="customer_support_agent-git-98207f02",
)

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

Lacak Penghubungan pada Pelayanan Model Databricks

Saat Anda menyebarkan LoggedModel ke Databricks Model Serving menggunakan Agent Framework dan MLflow 3 diinstal di lingkungan pengembangan Anda, penautan pelacakan dikonfigurasi secara otomatis.

Untuk melihat rekam jejak dari titik akhir Penyajian Model Databricks Anda:

  1. Arahkan ke Eksperimen MLflow yang aktif ketika Anda memanggil agents.deploy()
  2. Klik pada tab Jejak untuk melihat jejak
  3. Semua jejak secara otomatis ditautkan ke versi model tertentu yang melayani permintaan

Satu-satunya persyaratan adalah bahwa kode aplikasi Anda menggunakan pelacakan MLflow (baik melalui autologging atau instrumentasi manual dengan @mlflow.trace).

Langkah Selanjutnya

Untuk penyiapan pelacakan produksi lengkap termasuk autentikasi, pemantauan, dan pengumpulan umpan balik untuk penyebaran di luar Databricks Model Serving, lihat Pengamatan produksi dengan pelacakan.