Anpassade modelltjänster

En modelltjänst är en ändpunkt som översätter och dirigerar inferensförfrågningar till en eller flera modeller, med trafikdelning och reservvägar. Den stödjer realtidsförfrågningar samt batchinferens.

Skapa en anpassad modelltjänst för användningsfall såsom:

En modelloberoende endpoint för en applikation. Ge en kundsupportassistent en tjänst som heter production.ai.support-assistant. Ändra den underliggande modellen utan att ändra namnet som applikationen anropar.
Anpassad routning och reservlösningar. Använd trafikdelning för att skicka 10% trafik till en ny modell innan en bredare utrullning, eller konfigurera en backup-destination för misslyckade förfrågningar.
En budget för en arbetsbörda. Tagga en tjänst med project=support-assistant och koppla en månadsbudget till den taggen, med en varning när utgifterna når 1 000 USD.
Åtkomstkontroller för ett lag. Ge det juridiska teamet och dess applikationstjänsteledare tillgång till en legal-review tjänst och använd separata tjänster för andra team.
Hastighetsgränser för en arbetsbelastning. Konfigurera en testtjänst för 100 förfrågningar per minut och en produktionstjänst för 1 000 förfrågningar per minut med hjälp av servicehastighetsgränser.
Separat övervakning och loggar. Skicka en supportassistents förfrågningar och svar till en dedikerad inferenstabell så att dess trafik kan granskas separat från kodagenttrafiken.

För att fråga en Azure Databricks-served foundation-modell utan att skapa en tjänst, använd en systemlevererad modelltjänst i system.ai.

En tjänst kan dirigera till modeller som tillhandahålls via Azure Databricks, med hjälp av pay-per-token eller provisionerad genomströmning, eller till externa modeller via en modellleverantör. Du kan kombinera dessa destinationer i en och samma tjänst.

Anpassade modelltjänster är skyddade objekt i Unity Catalog. Användare anropar dem med sitt fullständigt kvalificerade namn, catalog.schema.name, i olika arbetsytor eller utanför Azure Databricks. Se Styrning och privilegier.

Requirements

Note

Unity Gateway stöds inte på Azure Government.

En Azure Databricks workspace i en region som stöds av Unity Gateway.
Unity Catalog har aktiverats för din arbetsyta. Se Aktivera en arbetsyta för Unity Catalog.
Om du vill skapa en modelltjänst måste du ha:
- USE CATALOG, USE SCHEMAoch CREATE SERVICE i katalogen och schemat där du skapar modelltjänsten.
- EXECUTE på varje modell som modelltjänsten refererar till som mål.
- EXECUTE, USE CATALOG, och USE SCHEMA på varje modellleverantör som modelltjänsten refererar till som destination.
- USE CATALOG, USE SCHEMA, och CREATE TABLE i katalogen och schemat där slutsatsdragningstabellen skapas, om du aktiverar slutsatsdragningsloggning.

Skapa en anpassad modelltjänst

Skapa en modelltjänst i Unity Gateway UI eller Catalog Explorer. För att skapa en programmatiskt, använd REST API, Azure Databricks SDKs, Azure Databricks CLI, Terraform eller Deklarative Automation Bundles (DABs).

Modelltjänster och modellleverantörer delar ett enda namnutrymme inom ett Unity-katalogschema. Du kan inte använda ett namn för en modelltjänst om en modellleverantör i schemat redan använder det, och vice versa.

Användargränssnitt (UI)

Gör något av följande:
- Klicka på AI Gateway i arbetsytans sidofält och klicka sedan på Skapa.
- I Katalogutforskaren går du till schemat där du vill skapa modelltjänsten och klickar sedan på Skapa>tjänstmodelltjänst>.
Ange ett namn för modelltjänsten och välj den katalog och det schema som du vill skapa den i. Om du börjar från Katalogutforskaren fyller Katalogutforskaren katalogen och schemat i förväg.
Välj den primära destinationen att betjäna. Denna destination kan vara en Azure Databricks-serverad modell som du har EXECUTE på och som Unity Gateway kan hantera, eller en modellleverantör som du har EXECUTE, USE CATALOG, och USE SCHEMA på.
Klicka på Skapa.

När du har skapat modelltjänsten öppnar Azure Databricks dess översiktssida, där du kan komma igång eller konfigurera ytterligare funktioner som slutsatsdragningsloggning.

REST API

Skicka en POST till /api/2.1/unity-catalog/model-services, skicka parent och model_service_id som frågeparametrar. Routingkonfigurationen måste ha minst en destination:

databricks api post \
  "/api/2.1/unity-catalog/model-services?parent=schemas/main.default&model_service_id=my_model_service" \
  --json '{
  "comment": "Routes chat traffic to a foundation model",
  "config": {
    "routing": {
      "destinations": [
        {
          "name": "primary",
          "destination_type": "DESTINATION_TYPE_PAY_PER_TOKEN_FOUNDATION_MODEL",
          "pay_per_token_config": { "model": "models/system.ai.databricks-gpt-5" },
          "traffic_percentage": 100
        }
      ]
    }
  }
}'

CLI

Skicka med det överordnade schemat och namnet på ett blad, och ange konfigurationen med --json. Routingkonfigurationen måste ha minst en destination. För att installera CLI:n, se Installera eller uppdatera Databricks CLI.

databricks ai-gateway create-model-service schemas/main.default my_model_service --json '{
  "comment": "Routes chat traffic to a foundation model",
  "config": {
    "routing": {
      "destinations": [
        {
          "name": "primary",
          "destination_type": "DESTINATION_TYPE_PAY_PER_TOKEN_FOUNDATION_MODEL",
          "pay_per_token_config": { "model": "models/system.ai.databricks-gpt-5" },
          "traffic_percentage": 100
        }
      ]
    }
  }
}'

Terraform

Skapa och hantera en modelltjänst med Databricks Terraform-leverantör och den databricks_ai_gateway_model_service resursen:

resource "databricks_ai_gateway_model_service" "example" {
  parent           = "schemas/main.default"
  model_service_id = "my_model_service"
  comment          = "Routes chat traffic to a foundation model"

  config = {
    routing = {
      destinations = [{
        name                 = "primary"
        destination_type     = "DESTINATION_TYPE_PAY_PER_TOKEN_FOUNDATION_MODEL"
        pay_per_token_config = { model = "models/system.ai.databricks-gpt-5" }
        traffic_percentage   = 100
      }]
    }
  }
}

DABs (Beta)

Definiera modelltjänsten i ett paket och distribuera den med databricks bundle deploy. Routingkonfigurationen måste ha minst en destination:

resources:
  model_services:
    my_model_service:
      parent: schemas/main.default
      model_service_id: my_model_service
      comment: Routes chat traffic to a foundation model
      config:
        routing:
          destinations:
            - name: primary
              destination_type: DESTINATION_TYPE_PAY_PER_TOKEN_FOUNDATION_MODEL
              pay_per_token_config:
                model: models/system.ai.databricks-gpt-5
              traffic_percentage: 100

Python SDK

Skapa och hantera en modelltjänst med Databricks SDK för Python:

from databricks.sdk.service import catalog as c

model_service = w.ai_gateway.create_model_service(
    parent="schemas/main.default",
    model_service_id="my_model_service",
    model_service=c.ModelService(
        comment="Routes chat traffic to a foundation model",
        config=c.ModelServiceConfig(
            routing=c.ModelServiceConfigRoutingConfig(
                destinations=[
                    c.ModelServiceConfigDestinationConfig(
                        name="primary",
                        destination_type=(
                            c.ModelServiceConfigDestinationConfigDestinationType
                            .DESTINATION_TYPE_PAY_PER_TOKEN_FOUNDATION_MODEL
                        ),
                        pay_per_token_config=c.ModelServiceConfigPayPerTokenConfig(
                            model="models/system.ai.databricks-gpt-5"
                        ),
                        traffic_percentage=100,
                    )
                ]
            )
        ),
    ),
)

Go-mjukvaruutvecklingskit

Skapa och hantera en modelltjänst med Databricks SDK för Go:

modelService, err := w.AiGateway.CreateModelService(ctx, catalog.CreateModelServiceRequest{
	Parent:         "schemas/main.default",
	ModelServiceId: "my_model_service",
	ModelService: catalog.ModelService{
		Comment: "Routes chat traffic to a foundation model",
		Config: &catalog.ModelServiceConfig{
			Routing: &catalog.ModelServiceConfigRoutingConfig{
				Destinations: []catalog.ModelServiceConfigDestinationConfig{{
					Name:            "primary",
					DestinationType: catalog.ModelServiceConfigDestinationConfigDestinationTypeDestinationTypePayPerTokenFoundationModel,
					PayPerTokenConfig: &catalog.ModelServiceConfigPayPerTokenConfig{
						Model: "models/system.ai.databricks-gpt-5",
					},
					TrafficPercentage: 100,
				}},
			},
		},
	},
})

Go Modular SDK

Skapa och hantera en modelltjänst med Databricks AI Gateway SDK för Go. Valfria fält är referenser, så exemplet använder en hjälpfunktion på en rad, func ptr[T any](v T) *T { return &v }.

modelService, err := c.CreateModelService(ctx, aigateway.CreateModelServiceRequest{
	Parent:         ptr("schemas/main.default"),
	ModelServiceId: ptr("my_model_service"),
	ModelService: &aigateway.ModelService{
		Comment: ptr("Routes chat traffic to a foundation model"),
		Config: &aigateway.ModelServiceConfig{
			Routing: &aigateway.ModelServiceConfig_RoutingConfig{
				Destinations: []aigateway.ModelServiceConfig_DestinationConfig{{
					Name:              ptr("primary"),
					DestinationType:   aigateway.ModelServiceConfig_DestinationConfig_DestinationType_DestinationTypePayPerTokenFoundationModel,
					TrafficPercentage: ptr(100),
					TypeConfig: &aigateway.ModelServiceConfig_DestinationConfig_TypeConfig_PayPerTokenConfig{
						PayPerTokenConfig: aigateway.ModelServiceConfig_PayPerTokenConfig{
							Model: ptr("models/system.ai.databricks-gpt-5"),
						},
					},
				}},
			},
		},
	},
})

Java SDK

Skapa och hantera en modelltjänst med Databricks SDK för Java:

ModelServiceConfig config =
    new ModelServiceConfig()
        .setRouting(
            new ModelServiceConfigRoutingConfig()
                .setDestinations(
                    Collections.singletonList(
                        new ModelServiceConfigDestinationConfig()
                            .setName("primary")
                            .setDestinationType(
                                ModelServiceConfigDestinationConfigDestinationType
                                    .DESTINATION_TYPE_PAY_PER_TOKEN_FOUNDATION_MODEL)
                            .setPayPerTokenConfig(
                                new ModelServiceConfigPayPerTokenConfig()
                                    .setModel("models/system.ai.databricks-gpt-5"))
                            .setTrafficPercentage(100L))));

ModelService modelService =
    w.aiGateway()
        .createModelService(
            new CreateModelServiceRequest()
                .setParent("schemas/main.default")
                .setModelServiceId("my_model_service")
                .setModelService(
                    new ModelService()
                        .setComment("Routes chat traffic to a foundation model")
                        .setConfig(config)));

JS Modular SDK

Skapa och hantera en modelltjänst med Databricks AI Gateway SDK för JavaScript:

import { ModelServiceConfig_DestinationConfig_DestinationType as DestType } from '@databricks/sdk-aigateway/v1';

const created = await client.createModelService({
  parent: 'schemas/main.default',
  modelServiceId: 'my_model_service',
  modelService: {
    comment: 'Routes chat traffic to a foundation model',
    config: {
      routing: {
        destinations: [
          {
            name: 'primary',
            destinationType: DestType.DESTINATION_TYPE_PAY_PER_TOKEN_FOUNDATION_MODEL,
            typeConfig: {
              $case: 'payPerTokenConfig',
              payPerTokenConfig: { model: 'models/system.ai.databricks-gpt-5' },
            },
            trafficPercentage: 100,
          },
        ],
      },
    },
  },
});

Ger tillgång till en modelltjänst

Som standard kan endast ägaren av modelltjänsten ställa frågor till den. För att låta andra söka en modelltjänst, ge dem EXECUTE tillgång till den, plus USE CATALOG och USE SCHEMA på dess katalog och schema. Om modelltjänsten loggar till en inferenstabell beviljar du SELECT för tabellen så att användare kan läsa de loggade begärandena och svaren.

Användargränssnitt (UI)

Öppna modelltjänsten i Katalogutforskaren, eller gå till AI Gateway och välj tjänsten.
Gå till fliken Behörigheter .
Klicka på Tillåt.
Välj de användare, grupper eller tjänsthuvudnamn som ska ge åtkomst till.
Välj behörigheten KÖR .
Klicka på Tillåt.

REST API

databricks api patch \
  "/api/2.1/unity-catalog/permissions/model_service/main.default.my_model_service" \
  --json '{
    "changes": [
      { "principal": "data-team", "add": ["EXECUTE"] }
    ]
  }'

CLI

Bevilja EXECUTE med Databricks CLI:n. För att installera CLI:n, se Installera eller uppdatera Databricks CLI.

databricks grants update model_service main.default.my_model_service \
  --json '{"changes": [{"principal": "data-team", "add": ["EXECUTE"]}]}'

Terraform

Grant EXECUTE med Databricks Terraform-leverantör och resursen databricks_grant :

resource "databricks_grant" "example" {
  model_service = "main.default.my_model_service"
  principal     = "data-team"
  privileges    = ["EXECUTE"]
}

DABs (Beta)

Lägg till ett grants block i modelltjänstresursen i ditt paket och distribuera om för att ge åtkomst.

resources:
  model_services:
    my_model_service:
      parent: schemas/main.default
      model_service_id: my_model_service
      comment: Routes chat traffic to a foundation model
      config:
        routing:
          destinations:
            - name: primary
              destination_type: DESTINATION_TYPE_PAY_PER_TOKEN_FOUNDATION_MODEL
              pay_per_token_config:
                model: models/system.ai.databricks-gpt-5
              traffic_percentage: 100
      grants:
        - principal: data-team
          privileges: [EXECUTE]

Python SDK

Grant EXECUTE med Databricks SDK för Python:

from databricks.sdk.service import catalog as c

w.grants.update(
    securable_type="model_service",
    full_name="main.default.my_model_service",
    changes=[c.PermissionsChange(principal="data-team", add=[c.Privilege.EXECUTE])],
)

Go-mjukvaruutvecklingskit

Bidrag EXECUTE med Databricks SDK för Go:

_, err := w.Grants.Update(ctx, catalog.UpdatePermissions{
	SecurableType: "model_service",
	FullName:      "main.default.my_model_service",
	Changes: []catalog.PermissionsChange{{
		Principal: "data-team",
		Add:       []catalog.Privilege{catalog.PrivilegeExecute},
	}},
})

Java SDK

Grant EXECUTE med Databricks SDK för Java:

w.grants().update(
    new UpdatePermissions()
        .setSecurableType("model_service")
        .setFullName("main.default.my_model_service")
        .setChanges(Arrays.asList(
            new PermissionsChange().setPrincipal("data-team").setAdd(Arrays.asList(Privilege.EXECUTE)))));

Se Upptäck och hantera åtkomst till modelltjänster om du vill veta mer om hur du beviljar och hittar åtkomst.

Konfigurera funktioner på en modelltjänst

Konfigurera hastighetsgränser, inferensloggning och skyddsräcken implementerade med tjänstepolicyer på modelltjänsten från Unity Gateway-gränssnittet. See:

Inferensloggning

När du aktiverar slutsatsdragningsloggning skapar Azure Databricks en ny, tom Unity Catalog-tabell med ett fördefinierat schema på den plats som du anger. Notera följande:

Du måste ha USE CATALOG, USE SCHEMAoch CREATE TABLE i målkatalogen och schemat.
Skaparen av modelltjänsten är ägare till slutsatsdragningstabellen. Inga andra användare har åtkomst om du inte beviljar den.
Om det redan finns en tabell på den angivna platsen misslyckas skapandet av modelltjänsten.
Slutsatsdragningstabellen har en oberoende livscykel från modelltjänsten. Om du släpper tabellen fortsätter modelltjänsten att fungera men slutar logga.

För mer om inferenstabeller, se Loggförfrågningar och svar på inferenstabeller.

Uppdatera en modelltjänst

Du måste vara ägare eller ha MANAGE.

Användargränssnitt (UI)

Redigera modelltjänstens konfiguration från Unity Gateway UI eller Catalog Explorer. Ändringarna genomförs direkt.

REST API

databricks api patch \
  "/api/2.1/unity-catalog/model-services/main.default.my_model_service?update_mask=comment" \
  --json '{"comment": "Updated: routes chat traffic"}'

CLI

databricks ai-gateway update-model-service model-services/main.default.my_model_service comment \
  --json '{"comment": "Updated: routes chat traffic"}'

Terraform

Redigera comment (eller något annat föränderligt fält) på resursen databricks_ai_gateway_model_service och applicera igen. Ändringarna genomförs direkt.

DABs (Beta)

Redigera comment (eller något annat variabelt fält) i bundle-resursen och kör databricks bundle deploy. Ändringarna genomförs direkt.

Python SDK

from databricks.sdk.service import catalog as c
from google.protobuf.field_mask_pb2 import FieldMask

updated = w.ai_gateway.update_model_service(
    name="model-services/main.default.my_model_service",
    update_mask=FieldMask(paths=["comment"]),
    model_service=c.ModelService(comment="Updated: routes chat traffic"),
)

Go-mjukvaruutvecklingskit

updated, err := w.AiGateway.UpdateModelService(ctx, catalog.UpdateModelServiceRequest{
	Name:         "model-services/main.default.my_model_service",
	UpdateMask:   *fieldmask.New([]string{"comment"}),
	ModelService: catalog.ModelService{Comment: "Updated: routes chat traffic"},
})

Go Modular SDK

mask, err := types.NewFieldMask[aigateway.ModelService]("comment")
updated, err := c.UpdateModelService(ctx, aigateway.UpdateModelServiceRequest{
	ModelService: &aigateway.ModelService{
		Name:    ptr("model-services/main.default.my_model_service"),
		Comment: ptr("Updated: routes chat traffic"),
	},
	UpdateMask: mask,
})

Java SDK

ModelService updated =
    w.aiGateway()
        .updateModelService(
            new UpdateModelServiceRequest()
                .setName("model-services/main.default.my_model_service")
                .setUpdateMask(FieldMask.newBuilder().addPaths("comment").build())
                .setModelService(
                    new ModelService().setComment("Updated: routes chat traffic")));

JS Modular SDK

import { modelServiceFieldMask } from '@databricks/sdk-aigateway/v1';

const updated = await client.updateModelService({
  modelService: {
    name: 'model-services/main.default.my_model_service',
    comment: 'Updated: routes chat traffic',
  },
  updateMask: modelServiceFieldMask('comment'),
});

Ta bort en modelltjänst

Du måste vara ägare eller ha MANAGE. Det går inte att ta bort modelltjänster som tillhandahålls av system.ai systemet.

Användargränssnitt (UI)

Öppna modelltjänsten i Unity Gateway UI eller Catalog Explorer och välj Ta bort från kebabmenyn.

REST API

databricks api delete "/api/2.1/unity-catalog/model-services/main.default.my_model_service"

CLI

databricks ai-gateway delete-model-service model-services/main.default.my_model_service

Terraform

Kör terraform destroy, eller ta bort resursblocket och applicera igen.

DABs (Beta)

Ta bort resursen från paketet och kör databricks bundle deploy för att ta bort den. databricks bundle destroy Fungerar också, men det tar bort alla resurser som paketet hanterar, inte bara denna.

Python SDK

w.ai_gateway.delete_model_service(name="model-services/main.default.my_model_service")

Go-mjukvaruutvecklingskit

err := w.AiGateway.DeleteModelService(ctx, catalog.DeleteModelServiceRequest{
	Name: "model-services/main.default.my_model_service",
})

Go Modular SDK

err := c.DeleteModelService(ctx, aigateway.DeleteModelServiceRequest{
	Name: ptr("model-services/main.default.my_model_service"),
})

Java SDK

w.aiGateway()
    .deleteModelService(
        new DeleteModelServiceRequest().setName("model-services/main.default.my_model_service"));

JS Modular SDK

await client.deleteModelService({ name: 'model-services/main.default.my_model_service' });

Styrning och privilegier

En modelltjänst är, som ett skyddsbart objekt i Unity Catalog:

Finns i en katalog och ett schema, där det ärver schemainställningar, till exempel arbetsytebindningar.
Innehåller standardmetadata för Unity Catalog, till exempel namn, ägare, kommentar och taggar.
Styrs av behörigheter i Unity Catalog, så du ger åtkomst med samma GRANT- och REVOKEsatser som du använder för tabeller, funktioner och modeller.
Kan identifieras i Katalogutforskaren, tillsammans med resten av dina Unity Catalog-tillgångar.

Följande behörigheter gäller:

Privileg	Description
`USE CATALOG`, `USE SCHEMA`	Få åtkomst till katalogen och schemat som innehåller modelltjänsten. Krävs för alla åtgärder.
`CREATE SERVICE`	Skapa modelltjänster i ett schema. Beviljas för katalogen eller schemat.
`EXECUTE`	Fråga en modelltjänst.
`MANAGE`	Ändra eller ta bort en modelltjänst och hantera dess bidrag. Ägaren har en övermängd av `MANAGE`.

Modelltjänster använder definierarens privilegier. Azure Databricks utvärderar en fråga mot ägarens rättigheter snarare än anroparens. När en användare frågar en modelltjänst kontrollerar Azure Databricks att ägaren har EXECUTE på de refererade destinationerna, såsom de underliggande modellerna och eventuella modellleverantörer. Uppringaren behöver inte direkt tillgång till dessa destinationer.

Limitations

Följande funktioner stöds inte:

Skapa och hantera modelltjänster med SQL.
Upptäcka modelltjänster med endast BROWSE-privilegiet.
Global sökning efter modelltjänster.

Ytterligare resurser

Feedback

Var den här sidan till hjälp?

Uppdaterades senast 2026-10-08