Pular para o conteúdo principal

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

O guia de versões de aplicativos mostrou como rastrear versões de aplicativos usando 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. No seu pipeline de CI/CD, é possível gerar um novo LoggedModel utilizando 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 metadados e feedback do usuário aos rastreamentos 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 você implanta um LoggedModel no Databricks servindo modelo usando o Agent Framework e MLflow 3 está instalado em seu ambiente de desenvolvimento, o rastreamento de vinculação é configurado 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).

UI de rastreios de produção

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