Pular para o conteúdo principal
Última atualização em

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 Apps ou servindo modelo O rastreamento de vinculação é configurado automaticamente para você. Para mais detalhes, consulte a seção Rastreamento de Vinculação no Databricks .

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é a versions tab para obter o ID LoggedModel. Em seu pipeline de CI/CD, você pode gerar um novo LoggedModel usando create_external_model() e lendo o atributo model_id do objeto retornado, conforme mostrado abaixo.
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. 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.
importante

MLFLOW_ACTIVE_MODEL_ID aceita apenas o ID LoggedModel gerado, que começa com m-. O MLflow registra esse valor em cada rastreamento como está e nunca resolve um nome de LoggedModel a partir dele. Se você definir como um nome, seus rastreamentos não serão vinculados à versão pretendida. Somente mlflow.set_active_model() aceita um nome.

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"

Vinculação automática de rastreamento​

importante

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 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="m-9dcd3a2b8e764e5bb4e8a89b4e4c6f21" \
  -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: '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'

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

Ao implantar MLflow 3 em aplicativos e garantir que ele esteja instalado em seu ambiente de desenvolvimento, o rastreamento de links é configurado automaticamente.

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

  1. Navegue até o experimento MLflow que estava ativo quando você fez a chamada. 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óximos passos​

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.

Nesta página