Aangepast model behouden dat gegevens verwerkt in Unity Catalog

Belangrijk

Deze functie bevindt zich in de bètaversie. Het is niet automatisch ingeschakeld voor alle klanten en functionaliteit is onderhevig aan wijzigingen. Neem contact op met uw Azure Databricks-accountteam om toegang te vragen.

Meer informatie over het configureren van eindpunttelemetrie om OpenTelemetry-logs, traceringen en metrische gegevens van uw aangepaste model-serving-eindpunten op te slaan in Unity Catalog-tabellen. Gebruik de persistente telemetriegegevens om hoofdoorzaakanalyse uit te voeren, de eindpuntstatus te bewaken en te voldoen aan de nalevingsvereisten met standaard SQL-query's.

Requirements

Uw werkruimte moet zijn ingeschakeld voor Unity Catalog. Standaardopslag (Arclight) wordt niet ondersteund.
U moet over USE CATALOG, USE SCHEMA, CREATE TABLE en MODIFY machtigingen beschikken voor de Unity Catalog-doelcatalogus en het schema waarin de logbestanden worden opgeslagen.
Een bestaand aangepast model serving-eindpunt of machtigingen om er een te creëren.
Uw werkruimte moet zich in een ondersteunde regio bevinden:
- canadacentral
- westus
- westus2
- southcentralus
- eastus
- eastus2
- centralus
- northcentralus
- swedencentral
- westeurope
- northeurope
- uksouth
- australiaeast
- southeastasia

Stap 1: Uw modelcode instrumentleren

Voeg instrumentatie toe aan uw modelcode om telemetrie vast te leggen.

Voeg toepassingslogboekregistratie toe aan uw model. Met eindpunttelemetrie wordt automatisch standaard Python-uitvoer logging vastgelegd. Er is geen OpenTelemetry SDK-instrumentatie vereist voor eenvoudige logboekregistratie.

import logging

class MyCustomModel(mlflow.pyfunc.PythonModel):
    def predict(self, context, model_input):
        # This log will be persisted to the <prefix>_otel_logs table
        logging.warning("Received inference request")

        try:
            # Your model logic here
            result = model_input * 2
            return result
        except Exception as e:
            # Error logs are also captured with severity 'ERROR'
            logging.error(f"Inference failed: {e}")
            raise e

Het root-logniveau is ingesteld op WARNING. Zie Problemen oplossen om het logboekregistratieniveau te wijzigen.

(Optioneel) Instrumenteer aangepaste metrische gegevens en traceringen met OpenTelemetry. Als u aangepaste metrische gegevens en traceringen wilt vastleggen buiten eenvoudige logboekregistratie, voegt u OpenTelemetry SDK-instrumentatie toe aan uw model. Vouw de volgende sectie uit voor een volledig voorbeeld waarin wordt getoond hoe u tellers, recordbereiken maakt en aangepaste kenmerken koppelt.

Voorbeeld: Aangepaste metrische gegevens, spans en modellogging met OpenTelemetry

Opmerking

Vanwege beperkingen in modelserialisatie moet u uw model naar een afzonderlijk bestand schrijven voordat u zich aanmeldt om fouten te voorkomen, zoals hieronder wordt weergegeven met behulp van %%writefile return_input_model.py.

%%writefile return_input_model.py
import os

import mlflow
from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.metrics import get_meter, set_meter_provider
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.trace import get_tracer, set_tracer_provider

# highlight-start
# ---- OTel initialization (per-worker) ----
resource = Resource.create({
    "worker.pid": str(os.getpid()),
})

otlp_trace_exporter = OTLPSpanExporter()
tracer_provider = TracerProvider(resource=resource)
tracer_provider.add_span_processor(BatchSpanProcessor(otlp_trace_exporter))
set_tracer_provider(tracer_provider)

otlp_metric_exporter = OTLPMetricExporter()
metric_reader = PeriodicExportingMetricReader(otlp_metric_exporter)
meter_provider = MeterProvider(metric_readers=[metric_reader], resource=resource)
set_meter_provider(meter_provider)

_tracer = get_tracer(__name__)
_meter = get_meter(__name__)
_prediction_counter = _meter.create_counter(
    name="prediction_count",
    description="Number of predictions made",
    unit="1"
)
# highlight-end


class ReturnInputModel(mlflow.pyfunc.PythonModel):
    def load_context(self, context):
        # highlight-start
        self.tracer = _tracer
        self.prediction_counter = _prediction_counter
        # highlight-end

    def predict(self, context, model_input):
        # highlight-next-line
        with self.tracer.start_as_current_span("ReturnInputModel.predict") as span:
            # highlight-next-line
            span.set_attribute("input_shape", str(model_input.shape))
            # highlight-next-line
            span.set_attribute("input_columns", str(list(model_input.columns)))
            # highlight-next-line
            self.prediction_counter.add(1)
            return model_input

mlflow.models.set_model(ReturnInputModel())

Leg het model vast en registreer het.

import pandas as pd
import mlflow
from mlflow.models import infer_signature

# Prepare tabular input/output for signature (pyfunc expects DataFrame)
input_df = pd.DataFrame({"inputs": ["hello world"]})
output_df = input_df.copy()  # model returns input unchanged

# Log the model with OpenTelemetry dependencies (using code-based logging to avoid serialization issues)
with mlflow.start_run():
    signature = infer_signature(input_df, output_df)

    model_info = mlflow.pyfunc.log_model(
        name="model",
        python_model="return_input_model.py",
        signature=signature,
        input_example=input_df,
        pip_requirements=[
            "mlflow==3.1",
            # highlight-next-line
            "opentelemetry-sdk",
            # highlight-next-line
            "opentelemetry-exporter-otlp-proto-http",
        ],
    )

# Register with serverless optimized deployment environment packing
# Use Unity Catalog name: catalog.schema.model_name
registered = mlflow.register_model(
    model_info.model_uri,
    MODEL_NAME,
    env_pack="databricks_model_serving"
)

Stap 2: de bestemming van de Unity-catalogus voorbereiden

Voordat u uw eindpunt maakt, moet u ervoor zorgen dat u een catalogus en schema hebt die gereed is om de telemetriegegevens te ontvangen. Azure Databricks maakt automatisch de benodigde tabellen in dit schema als deze nog niet bestaan.

Navigeer in Catalog Explorer naar de catalogus en het schema dat u wilt gebruiken (bijvoorbeeld my_catalog.observability).

Stap 3: Eindpunttelemetrie inschakelen

U kunt telemetrie inschakelen bij het maken van een nieuw eindpunt of toevoegen aan een bestaand eindpunt.

Nieuwe eindpunt

Telemetrie inschakelen in de gebruikersinterface:

Navigeer naar Serveren in de linkerzijbalk.
Klik op Een service-eindpunt maken.
Vouw in de sectie Eindpunttelemetrie (gemarkeerd preview) de configuratieopties uit.
Locatie van Unity Catalog: Selecteer de doelcatalogus en het schema dat in stap 2 is voorbereid.
(Optioneel) Tabelvoorvoegsel: Voer een voorvoegsel in voor de gegenereerde tabellen. Als u het veld leeg laat, is er geen voorvoegsel. De tabellen hebben de naam <prefix>_otel_logs, <prefix>_otel_spansen <prefix>_otel_metrics.
Voltooi de rest van de eindpuntconfiguratie (modelselectie, rekeninstellingen) en klik op Maken.

Ga als volgt te werk met de API:

Gebruik de API om telemetrie in te schakelen

curl -X POST -H "Authorization: Bearer <your-token>" \
https://<workspace-url>/api/2.0/serving-endpoints \
-d '{
  "name": "my-custom-logging-endpoint",
  "config": {
    "served_entities": [
      {
        "name": "my-model",
        "entity_name": "my-model",
        "entity_version": "1",
        "workload_size": "Small",
        "scale_to_zero_enabled": true
      }
    ],
    "telemetry_config": {
      "table_names": {
        "logs_table": "my_catalog.observability.custom_endpoint_logs",
        "metrics_table": "my_catalog.observability.custom_endpoint_metrics",
        "traces_table": "my_catalog.observability.custom_endpoint_spans"
      }
    }
  }
}'

Bestaand eindpunt

Opmerking

Bijwerken activeert een nieuwe implementatie. Wijzigingen worden van kracht zodra de implementatie is voltooid.

Telemetrie inschakelen in de gebruikersinterface:

Klik op de pagina eindpuntweergave, in het rechterdeelvenster, onder de sectie Eindpunttelemetrie , op Toevoegen.
Locatie van Unity Catalog: Selecteer de doelcatalogus en het schema dat in stap 2 is voorbereid.
(Optioneel) Tabelvoorvoegsel: Voer een voorvoegsel in voor de gegenereerde tabellen. Als het veld leeg blijft, is er geen voorvoegsel. De tabellen hebben de naam <prefix>_otel_logs, <prefix>_otel_spansen <prefix>_otel_metrics.
Klik op Bijwerken.

Stap 4: Telemetriegegevens verifiëren en er query's op uitvoeren

Nadat het eindpunt verkeer heeft ontvangen, stromen telemetriegegevens naar de geconfigureerde Unity Catalog-tabellen.

Ga naar Catalog Explorer of de SQL-editor.
Zoek de tabel met de naam <prefix>_otel_logs in het geconfigureerde schema.

Voer een query uit om te controleren of gegevens stromen:

SELECT * FROM <catalog>.<schema>.<prefix>_otel_logs
LIMIT 10;

Telemetriegegevens opvragen

In de volgende voorbeelden ziet u veelvoorkomende query's.

Als u het volledige schema van een telemetrietabel wilt weergeven, voert u het volgende uit:

DESCRIBE TABLE <catalog>.<schema>.<prefix>_otel_logs;

Gebruik deze kolommen om telemetriegegevens te filteren en correleren:

timestamp
severity_text
body
trace_id
span_id
attributes — een kaart die gebeurtenisspecifieke metagegevens bevat.

Controleren op fouten in het afgelopen uur

SELECT
  timestamp,
  severity_text,
  body,
  attributes
FROM <catalog>.<schema>.<prefix>_otel_logs
WHERE
  severity_text = 'ERROR'
  AND timestamp > current_timestamp() - INTERVAL 1 HOUR
ORDER BY timestamp DESC;

Troubleshooting

Logboeken worden niet weergegeven in tabel: het basislogboekniveau is standaard ingesteld om overhead te WARNING verminderen. Als u logboeken met een lagere ernst wilt vastleggen, wijzigt u het niveau in uw modelcode:

class MyModel(mlflow.pyfunc.PythonModel):
    def load_context(self, context):
        root = logging.getLogger()
        root.setLevel(logging.DEBUG)
        for handler in root.handlers:
            handler.setLevel(logging.DEBUG)

Beperkingen

De volgende limieten zijn van toepassing op eindpunttelemetrie:

Schema-evolutie in de doeltabel wordt niet ondersteund.
Alleen beheerde Delta-tabellen worden ondersteund. Externe opslag en Standaardopslag van Arclight worden niet ondersteund.
De tabellocatie moet zich in dezelfde regio bevinden als uw werkruimte.
Alleen tabelnamen met ASCII-letters, cijfers en onderstrepingstekens worden ondersteund.
Het opnieuw maken van een doeltabel wordt niet ondersteund.
Alleen duurzaamheid van één beschikbaarheidszone (één az) wordt ondersteund.
Levering is ten minste één keer. Een bevestiging van de server betekent dat de gegevens betrouwbaar zijn en in de Delta-tabel staan.
Records moeten elk kleiner zijn dan 10 MB.
Aanvragen moeten elk kleiner zijn dan 30 MB.
Logboeklijnen moeten elk kleiner zijn dan 1 MB.
Telemetrie latentie verslechtert wanneer het meer dan 2500 QPS bereikt.
Logboeken worden een paar seconden in de Tabel Unity Catalog weergegeven nadat ze zijn verzonden.

Feedback

Is deze pagina nuttig?

Last updated on 2026-03-15