Pular para o conteúdo principal

Vincule traços de produção às versões do aplicativo

O guia de rastreamento de versões de aplicativos mostrou como rastrear versões de aplicativos usando o site LoggedModel durante o desenvolvimento.

Ao implantar um LoggedModel na produção, o senhor precisa vincular os rastreamentos que ele gera à versão específica para monitoramento e depuração. Este guia mostra como configurar sua implantação para incluir informações de versão nos traces de produção.

dica

implantado em Databricks servindo modelo ? A vinculação de rastreamento é configurada automaticamente para você. Pule para Trace Linking em Databricks servindo modelo para obter detalhes.

Pré-requisitos​

  1. Para implementações de produção fora do Databricks servindo modelo , instale o pacote mlflow-tracing:

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

    Esse pacote é otimizado especificamente para ambientes de produção, oferecendo:

    • Dependências mínimas para implantações mais rápidas e enxutas

    • Otimizações de desempenho para rastreamento de alto volume

nota

O MLflow 3 é necessário para o rastreamento da produção. MLflow O 2.x não é compatível com implementações de produção devido a limitações de desempenho e à falta de recursos para uso em produção.

  1. Crie um experimento MLflow seguindo o início rápido de configuração do ambiente.

Configuração variável de ambiente​

  1. Navegue até as versões tab para obter o ID LoggedModel. Em seu pipeline de CI/CD, o senhor pode gerar um novo LoggedModel usando create_external_model(), conforme mostrado abaixo. Sugerimos usar o
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)
  1. Adicione a ID LoggedModel à configuração do seu ambiente de produção na variável de ambiente MLFLOW_ACTIVE_MODEL_ID juntamente com as variáveis de rastreamento padrão do MLflow do início rápido de configuração do ambiente.
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 LoggedModel ID
# Ensure this matches a LoggedModel in your MLFlow Experiment
export MLFLOW_ACTIVE_MODEL_ID="customer_support_agent-git-98207f02"

Vinculação automática de rastreamento​

important

Quando o senhor define a variável de ambiente MLFLOW_ACTIVE_MODEL_ID, todos os rastreamentos são automaticamente vinculados a esse LoggedModel . O senhor não precisa marcar manualmente os traços - o MLflow cuida disso para o senhor!

O código do seu aplicativo permanece exatamente o mesmo que durante o desenvolvimento:

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}

Para adicionar contexto adicional aos seus rastreamentos (como IDs de usuário, IDs de sessão ou metadados personalizados), consulte Adicionar contexto aos rastreamentos de produção no guia de rastreamento de produção.

Exemplos de implantação​

Docker​

Quando implantado com Docker, passe todas as variáveis de ambiente necessárias pela configuração do seu contêiner:

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

executar o contêiner com variável de ambiente:

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

Kubernetes​

Para implantações do Kubernetes, use ConfigMaps e Secrets para gerenciar a configuração:

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

Consultando rastreamentos específicos da versão​

Uma vez implantado, o senhor pode view rastrear na UI de rastreamento MLflow ou pode consultar os rastreamentos por versão do modelo em SDK:

Python
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")

Trace Linking em Databricks servindo modelo​

Quando o senhor implanta um LoggedModel para Databricks servindo modelo usando o Agent Framework e o MLflow 3 é instalado em seu ambiente de desenvolvimento, a vinculação de rastreamento é configurada automaticamente.

Para view traços de seu Databricks servindo modelo endpoint:

  1. Navegue até o MLflow Experiment que estava ativo quando o senhor chamou agents.deploy()
  2. Clique em Traces tab para view traces
  3. Todos os rastreamentos são automaticamente vinculados à versão específica do modelo que atende às solicitações

O único requisito é que o código do seu aplicativo use o rastreamento do MLflow (por meio de autologging ou instrumentação manual com @mlflow.trace).

Próximas etapas​

Para obter a configuração completa do rastreamento da produção, incluindo autenticação, monitoramento e coleta de feedback para implementações fora do Databricks servindo modelo, consulte Observabilidade da produção com rastreamento.

Última atualização em