Aangepaste LLM's leveren met aangepaste modelbediening

Deze pagina laat zien hoe je je eigen LLM kunt hosten op een Model Serving GPU-endpoint. Elk model dat vLLM draait wordt een productie-endpoint met een OpenAI-compatibele API. Zo werkt het:

• Je draait de inferentieserver, zoals vLLM, en kiest de versie en instellingen ervan.
• Je test de server in een AI Runtime-notebook . Een verkeerde vlag of een out-of-memory fout verschijnt binnen enkele seconden in plaats van na een deployment.
• Je deployt hetzelfde commando en dezelfde omgeving die je hebt gebouwd en waarvan je weet dat ze werken op een productie-endpoint.

Quickstart

Importeer het volgende notebook in je werkruimte en klik op Run all op AI Runtime met een A10 GPU. Na ongeveer 15 minuten heb je een Qwen3.5-4B endpoint dat OpenAI-compatibele chatverzoeken beantwoordt.

Draai Qwen3.5-4B met vLLM

Notebook krijgen

Wanneer gebruikt u aangepaste LLM-server

Gebruik aangepaste LLM-hosting in de volgende gevallen:

• Je hebt een LLM verfijnd op AI Runtime en wilt het uitrollen. Zie het onderstaande gedeelte voor een voorbeeld.
• Je wilt een open model aanbieden dat Foundation Model API's (FMAPI) niet ondersteunt, zoals een nieuwe LLM, een spraak-naar-tekstmodel of een embeddingmodel.
• Je wilt de runtime of architectuur van een LLM aanpassen en hebt controle nodig over de runtime en omgeving.

Gebruik in de volgende gevallen geen aangepaste LLM-serving:

• FMAPI levert het model dat je nodig hebt, ongewijzigd. FMAPI is eenvoudiger te gebruiken en sterk geoptimaliseerd.
• Het model past niet op één enkele GPU met ongeveer 80 GB geheugen. Bijvoorbeeld, Qwen3.8-27B en gpt-oss-120b passen, maar Kimi K3 en GLM 5.3 niet.
• Je hebt frontier-niveau doorvoer of prijs per token nodig zonder afstemming. De prestaties komen overeen met open source vLLM op dezelfde GPU.

Requirements

Custom LLM-serving heeft de volgende vereisten:

• Je werkruimte moet AI Runtime hebben.
• Je moet het model loggen vanuit een AI Runtime-notebook. Een model dat wordt gelogd vanuit een CPU-omgeving verpakt CPU-afhankelijkheden, en het GPU-eindpunt start niet op.
• Je moet toestemming hebben om modellen te maken in een Unity Catalog-schema.
• Je moet het model registreren bij env_pack="databricks_model_serving". Aangepaste LLM-modelserving is gebouwd op express-deployments, die de omgeving van het notebook met het model verpakken.
• Je moet MLflow 3.12 of hoger en mlserver databricks-sdk 0.102.0 of hoger gebruiken. De AI v6-omgeving bevat beide.

Starternotebooks

Elke notebook brengt één model van Hugging Face naar een opgevraagd endpoint, zoals de quickstart. Gebruik er een zoals die is, of begin ermee om je eigen model te hosten.

AI v6 en Standard v6 zijn AI runtime-omgevingen. AI v6 wordt geleverd met vLLM, PyTorch, Transformers en andere gangbare machine learning-pakketten die vooraf zijn geïnstalleerd en klaar voor gebruik. Zie de AI v6 pakketlijst. Een standaard v6-notebook installeert vLLM zelf, dus je kiest de versie ervan. Gebruik een Standard v6 notebook wanneer je model een nieuwere vLLM of transformers nodig heeft dan AI v6, zoals bij Muse Glimmer.

Host je eigen model

Om een ander model te serveren, kies je het starternotebook met dezelfde taak en de GPU die je model nodig heeft. Verander MODEL_REPO_ID en de vlaggen in vllm_command, en voer daarna het notitieboek uit. Elk notitieboek voert de volgende stappen uit:

1. Download de modelgewichten van Hugging Face, of haal ze bij een trainingscheckpoint.
2. Start vLLM in de notebook en voer er een query op uit.
3. Log het model met het vLLM-commando als instappunt en registreer het in Unity Catalog als een express deployment.
4. Maak een serving-endpoint aan, dat hetzelfde commando start.
5. Voer een query uit op het eindpunt met de OpenAI-client, de Databricks SDK of SQL ai_query.

In het volgende voorbeeld bevat de metadata van het model de taak en de entrypoint:

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

Bied een fijnafgesteld model aan

Fine-tune een model op AI Runtime en serveer het vanuit hetzelfde notebook. Zie bijvoorbeeld Supervised fine-tuning (Full) en serveren van Qwen3.5-0.8B. De tutorial fijntunet Qwen3.5-0.8B op een enkele H100, vergelijkt antwoorden voor en na de training, en serveert het fijnafgestelde model.

Ondersteunde taken

task in de metadata van het model stelt in welke API het eindpunt bedient. Je server moet de OpenAI-compatibele API voor die taak beschikbaar stellen. Andere taken, zoals llm/v1/completions, worden niet ondersteund. De volgende tabel geeft een overzicht van de ondersteunde taken.

Kies een GPU

Azure Databricks raadt aan om te ontwikkelen op dezelfde GPU waarop je uitrolt, dus de instellingen die je test zijn de instellingen die je deployeert. De volgende tabel geeft een overzicht van de GPU's voor aangepaste LLM-servering.

Veelvoorkomende problemen

De volgende problemen komen het meest voor wanneer je een notebook vervangt:

• De download faalt in /Workspace, die geen bestanden van meerdere GB accepteert. Download de gewichten naar de lokale schijf, zoals de starternotebooks doen.
• De lokale server start niet op. AI Runtime-notebooks staan alleen poorten van 3000 naar 3999 toe, dus test op een van die poorten. Alleen het entrypoint gebruikt poort 8080, en het moet verder overeenkomen met het commando dat je hebt getest.
• Het eindpunt kan de gewichten niet vinden. Het entrypoint draait in de artefactenmap van het model, dus --model moet verwijzen naar de map met gewichten die je hebt gelogd.
• Een embeddingmodel levert geen embeddings. Start vLLM met --runner pooling.
• Registratie mislukt met TimeoutError('Timed out after 0:05:00') bij het uploaden van model_version.tar of model_environment.tar. Upgrade naar databricks-sdk 0.102.0 of hoger en registreer het model opnieuw.

Een eindpunt maken

Maak het eindpunt aan vanuit de Serving UI of met de Databricks SDK, zoals de startnotebooks doen. workload_type kiest de GPU, en workload_size (Small, Medium, of Large) stelt het aantal replica's in.

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

Autoschalen naar nul en capaciteit

Op dit moment schalen aangepaste llm-endpoints niet automatisch, dus dimensioneer workload_size op je piekverkeer.

Bij schaal-tot-nul stoppen alle replica's van een inactief eindpunt. Het volgende verzoek duurt één tot enkele minuten terwijl vLLM het model opnieuw laadt en alle replica's opstarten. Azure Databricks raadt aan om schaal-tot-nul uit te schakelen voor productieverkeer.

Voer query's uit op uw eindpunt

Een ready chat-endpoint verschijnt in de AI Playground. De volgende voorbeelden bevragen een endpoint met de Databricks SDK, de OpenAI-client en REST.

Databricks SDK

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

OpenAI-client

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

Sommige embeddingmodellen verwachten een prefix op elke invoer, zoals search_query: of search_document:. Controleer de modelkaart.

Uw eindpunt bewaken

Het tabblad Logs van het endpoint toont de stdout en stderr van je server live. De logs-API geeft dezelfde output terug.

Azure Databricks stuurt de metrics van je vLLM-server door en zet deze in kaart op het endpointtabblad Metrics:

• Latentie: tijd tot het eerste token, tijd per outputtoken, verzoeklatentie en wachtrijtijd.
• Belasting: verzoeken draaien en wachten.
• KV-cache: gebruik en hitrate.
• Doorvoer: prompt- en generatietokens per seconde.

De export metrics API levert dezelfde metrics terug in Prometheus-formaat, dus je kunt ze scrapen in Prometheus of Datadog.

Met telemetrie ingeschakeld, slaat Azure Databricks ook de serverlogs en de vLLM Prometheus-metrics op in Unity Catalog-tabellen, zodat je ze over langere periodes kunt opvragen. Zie Persistent aangepast model dat gegevens verwerkt in Unity Catalog.

Pricing

Je betaalt per GPU-instance uur, hetzelfde als voor andere GPU custom model serving. Zie Model Serving pricing.

Beperkingen en beschikbaarheid van regio's

Je registreert een aangepaste LLM vanuit AI Runtime, dus aangepaste LLM-serving is beschikbaar in dezelfde regio's als serverless GPU-rekenkracht. Dat zijn Amerikaanse regio's op AWS en Azure. GCP wordt niet ondersteund.

De volgende functies komen binnenkort:

• LoRA-adapters.
• Bedienen over regio's heen.
• Modellen loggen buiten AI Runtime, bijvoorbeeld vanuit Databricks Runtime of CPU serverless.

De volgende functies worden niet ondersteund:

• Routering met awareness van de KV-cache.
• Route-optimalisatie.