Servicio de LLM personalizados con Modelo de servicio personalizado

Esta página muestra cómo servir tu propio LLM en un endpoint de GPU Model Serving (GPU). Cualquier modelo que ejecute vLLM se convierte en un endpoint de producción con una API compatible con OpenAI. Así es como funciona:

• Ejecutas el servidor de inferencias, como vLLM, y eliges su versión y configuración.
• Pruebas el servidor en un notebook de AI Runtime. Un indicador erróneo o un error de falta de memoria se detecta en segundos, en lugar de tras una implementación.
• Despliegas el mismo comando y entorno que has construido y que sabes que funciona en un endpoint de servicio de producción.

Quickstart

Importa el siguiente cuaderno a tu espacio de trabajo y haz clic en Ejecutar todo en AI Runtime con una GPU A10. En unos 15 minutos, tienes un endpoint Qwen3.5-4B que responde a solicitudes de chat compatibles con OpenAI.

Sirve Qwen3.5-4B con vLLM

Obtención del cuaderno

Cuándo usar el servicio LLM personalizado

Utiliza un servicio de serving de LLM personalizado en los siguientes casos:

• Has ajustado un LLM en AI Runtime y quieres servirlo. Consulta la sección siguiente para un ejemplo.
• Deseas servir un modelo abierto que las API de modelos base (FMAPI) no admiten, como un nuevo LLM, un modelo de conversión de voz a texto o un modelo de incrustación.
• Quieres cambiar el tiempo de ejecución o la arquitectura de un LLM y necesitas controlar el tiempo de ejecución y el entorno.

No utilices el serving personalizado de LLM en los siguientes casos:

• FMAPI proporciona el modelo que necesitas, sin cambios. FMAPI es más sencillo de usar y está altamente optimizado.
• El modelo no cabe en una sola GPU con unos 80 GB de memoria. Por ejemplo, Qwen3.8-27B y gpt-oss-120b encajan, pero Kimi K3 y GLM 5.3 no.
• Necesitas un rendimiento de vanguardia o un precio por token sin necesidad de ajuste. El rendimiento coincide con el vLLM código abierto en la misma GPU.

Requirements

El servicio de LLM personalizado tiene los siguientes requisitos:

• Tu espacio de trabajo debe tener AI Runtime.
• Debes registrar el modelo desde un cuaderno de IA Runtime. Un modelo registrado desde un entorno de CPU empaqueta dependencias de CPU, y el endpoint de la GPU no se inicia.
• Debes tener permiso para crear modelos en un esquema de Unity Catalog.
• Debes registrar el modelo con env_pack="databricks_model_serving". La puesta en servicio de LLM personalizados se basa en implementaciones exprés, que empaquetan el entorno del cuaderno junto con el modelo.
• Debes usar MLflow 3.12 o superior y databricks-sdk 0.102.0 o superior. El entorno de IA v6 incluye ambos.

Cuadernos de inicio

Cada cuaderno lleva un modelo de Hugging Face a un punto de conexión consultado, como el inicio rápido. Ejecuta uno tal cual, o empieza desde uno para poner en producción tu propio modelo.

AI v6 y Standard v6 son entornos de IA Runtime. AI v6 viene con vLLM, PyTorch, Transformers y otros paquetes de aprendizaje automático comunes preinstalados y listos para su uso. Consulta la lista de paquetes de AI v6. Un notebook estándar v6 instala vLLM automáticamente, así que eliges su versión. Usa un notebook Standard v6 cuando tu modelo necesite un vLLM o transformers más nuevos que los que incluye AI v6, como con Muse Glimmer.

Pon en servicio tu propio modelo

Para servir a otro modelo, elige el notebook inicial con la misma tarea y la GPU que necesite tu modelo. Cambia MODEL_REPO_ID y los indicadores en vllm_command, y luego ejecuta el cuaderno. Cada cuaderno ejecuta los siguientes pasos:

1. Descarga los pesos del modelo de Hugging Face, o consíguelos desde un punto de control de entrenamiento.
2. Inicia vLLM en el cuaderno y consúltalo.
3. Registra el modelo con el comando vLLM como punto de entrada y regístralo en Unity Catalog como una implementación rápida.
4. Crea un endpoint de servicio, que inicie el mismo comando.
5. Consulta el endpoint con el cliente OpenAI, el SDK Databricks o SQL ai_query.

En el siguiente ejemplo, el metadata del modelo contiene la tarea y el punto de entrada:

import mlflow
from mlflow.pyfunc.model import ChatCompletionResponse, ChatModel

# The endpoint runs the entrypoint and never calls predict, but MLflow needs a model class to log.
class Placeholder(ChatModel):
    def predict(self, context, messages, params):
        return ChatCompletionResponse.from_dict({"choices": []})

model_info = mlflow.pyfunc.log_model(
    name="my-model",
    python_model=Placeholder(),
    artifacts={"model_dir": "my-model"},  # the weights folder, which --model names
    metadata={
        "task": "llm/v1/chat",
        "entrypoint": (
            "python -u -m vllm.entrypoints.openai.api_server "
            "--model my-model --served-model-name my-model "
            "--host 0.0.0.0 --port 8080 --max-model-len 16384"
        ),
    },
)
mlflow.register_model(model_info.model_uri, "<catalog>.<schema>.my_model", env_pack="databricks_model_serving")

Despliega un modelo ajustado

Ajusta un modelo en AI Runtime y sírvelo desde el mismo cuaderno. Para un ejemplo, véase Ajuste fino supervisado (Completo) y servicio de Qwen3.5-0.8B. El tutorial ajusta finamente Qwen3.5-0.8B en un solo H100, compara respuestas antes y después del entrenamiento, y despliega el modelo ajustado.

Tareas compatibles

El task de los metadatos del modelo establece la API que ofrece el punto de conexión. Tu servidor debe exponer la API compatible con OpenAI para esa tarea. Otras tareas, como llm/v1/completions, no están soportadas. La siguiente tabla muestra las tareas admitidas.

Elige una GPU

Azure Databricks recomienda desarrollar en la misma GPU en la que se ofrece el servicio, de modo que la configuración que se prueba sea la misma que se implementa. La siguiente tabla lista las GPUs para el servicio personalizado de LLM.

Problemas comunes

Los siguientes problemas son los más comunes cuando cambias un portátil:

• La descarga falla en /Workspace, que no acepta archivos de varios GB. Descarga los pesos al disco local, como hacen los notebooks de inicio.
• El servidor local no arranca. Los notebooks de AI Runtime solo permiten los puertos del 3000 al 3999, así que prueba en uno de ellos. Solo el entrypoint usa el puerto 8080, y, por lo demás, debe coincidir con el comando que has probado.
• El endpoint no puede encontrar los pesos. El punto de entrada se ejecuta en la carpeta de artefactos del modelo, así que --model debe nombrar la carpeta de pesos que registraste.
• Un modelo de embeddings no proporciona embeddings. Empieza vLLM con --runner pooling.
• El registro falla con TimeoutError('Timed out after 0:05:00') al subir model_version.tar o model_environment.tar. Actualiza a databricks-sdk 0.102.0 o superior y registra el modelo de nuevo.

Crear un punto de conexión

Crea el endpoint desde la interfaz de usuario de Serving o con el SDK de Databricks, como hacen los cuadernos iniciales. workload_type elige la GPU, y workload_size (Small, Medium, o Large) establece el número de réplicas.

ServedEntityInput(
    entity_name="<catalog>.<schema>.<model>",
    entity_version="<version>",
    workload_type=ServingModelWorkloadType.GPU_MEDIUM,
    workload_size="Small",
    scale_to_zero_enabled=False,
)

Escalado a cero y capacidad

Actualmente, los endpoints LLM personalizados no escalan dinámicamente automáticamente, así que aumenta el tamaño workload_size para tu tráfico máximo.

Con el escalado a cero, un punto final inactivo detiene todas las réplicas. La siguiente solicitud tarda de uno a varios minutos mientras vLLM carga el modelo de nuevo y todas las réplicas se inician. Azure Databricks recomienda desactivar el scale-to-zero para el tráfico de producción.

Consultar su punto de conexión

Un endpoint de chat listo aparece en el AI Playground. Los siguientes ejemplos consultan un punto final con el SDK Databricks, el cliente OpenAI y REST.

SDK de Databricks

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.serving import ChatMessage, ChatMessageRole

w = WorkspaceClient()
w.serving_endpoints.query(
    name="<endpoint-name>",
    messages=[ChatMessage(role=ChatMessageRole.USER, content="Hello")],
)

Cliente OpenAI

from openai import OpenAI

client = OpenAI(api_key=DATABRICKS_TOKEN, base_url=f"{DATABRICKS_HOST}/serving-endpoints")

client.chat.completions.create(model="<endpoint-name>", messages=[{"role": "user", "content": "Hello"}])
client.embeddings.create(model="<endpoint-name>", input=["The quick brown fox jumps over the lazy dog."])
with open("speech.flac", "rb") as audio:
    client.audio.transcriptions.create(model="<endpoint-name>", file=audio)

REST: chat

curl -X POST \
  -u "token:$DATABRICKS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"messages":[{"role":"user","content":"Hello"}]}' \
  https://<workspace-url>/serving-endpoints/<endpoint-name>/invocations

REST: embeddings

curl -X POST \
  -u "token:$DATABRICKS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"input":["The quick brown fox jumps over the lazy dog."]}' \
  https://<workspace-url>/serving-endpoints/<endpoint-name>/invocations

Algunos modelos de incrustación esperan un prefijo en cada entrada, como search_query: o search_document:. Revisa la tarjeta del modelo.

Supervisa tu dispositivo terminal

La pestaña Logs del punto de conexión muestra los stdout y stderr de tu servidor en tiempo real. La API de logs devuelve la misma salida.

Azure Databricks reenvía las métricas de tu servidor vLLM y las grafica en la pestaña de Métricas del endpoint:

• Latencia: tiempo hasta el primer token, tiempo por token de salida, latencia de petición y tiempo de cola.
• Carga: solicitudes en marcha y en espera.
• Caché KV: uso y tasa de acierto.
• Rendimiento: tokens de prompt y generación por segundo.

La API de exportación de métricas devuelve las mismas métricas en formato Prometheus, por lo que puede importarlas a Prometheus o Datadog.

Con la telemetría activada, Azure Databricks también guarda los registros del servidor y las métricas de Prometheus de vLLM en tablas de Unity Catalog, para que puedas consultarlas durante periodos más largos. Consulta Almacenamiento persistente de datos de Modelo de servicio personalizados en Unity Catalog.

Pricing

Pagas por hora de instancia de GPU, igual que para otros servicios de modelos personalizados con GPU. Consulta precios de Servicio de Modelos.

Limitaciones y disponibilidad de región

Registras un LLM personalizado desde AI Runtime, así que el servicio de LLM personalizado está disponible en las mismas regiones que el computo con GPU serverless. Esas son regiones de EE. UU. en AWS y Azure. GCP no es compatible.

Las siguientes funcionalidades llegarán pronto:

• Adaptadores LoRA.
• Servicio entre regiones.
• Registrar modelos fuera de AI Runtime, por ejemplo desde Databricks Runtime o CPU serverless.

No se admiten las siguientes características:

• Enrutamiento adaptado a la caché KV.
• Optimización de rutas.