Serviços de modelo personalizados
Um serviço de modelo é um Endpoint que traduz e roteia solicitações de inferência para um ou mais modelos, com divisão de tráfego e fallback. Ele é compatível com solicitações em tempo real, além de inferência em lotes.
Crie um serviço de modelo personalizado para casos de uso como:
- Um endpoint agnóstico de modelo para um aplicativo. Dê a um assistente de suporte ao cliente um serviço chamado
production.ai.support-assistant. Altere o modelo subjacente sem alterar o nome que o aplicativo chama. - Roteamento personalizado e fallback. Use divisão de tráfego para enviar 10% do tráfego para um novo modelo antes de uma implantação mais ampla ou configure um destino de backup para solicitações com falha.
- Um orçamento para uma carga de trabalho. Atribua uma tag a um serviço com
project=support-assistante defina o escopo de um orçamento mensal para essa tag, com um alerta em R$ 1.000 de gastos. - Controles de acesso para uma equipe. Conceda à equipe jurídica e aos seus Service Principal de aplicativo acesso a um serviço
legal-reviewe use serviços separados para outras equipes. - Limites de taxa para uma carga de trabalho. Configure um serviço de teste para 100 solicitações por minuto e um serviço de produção para 1.000 solicitações por minuto usando limites de taxa de serviço.
- Separe o monitoramento e os Logs. Envie solicitações e respostas de um assistente de suporte para uma tabela de inferência dedicada para que seu tráfego possa ser inspecionado separadamente do tráfego do agente de codificação.
Para fazer query em um modelo base atendido pelo Databricks sem criar um serviço, use um serviço de modelo fornecido pelo sistema em system.ai.
Um serviço pode fazer o roteamento para modelos servidos pelo Databricks, usando pagamento por token ou throughput provisionado, ou para modelos externos por meio de um provedor de modelo. Você pode combinar esses destinos em um único serviço.
Os serviços de modelo personalizado são protegíveis do Unity Catalog. Os chamadores os invocam pelo nome totalmente qualificado, catalog.schema.name, em workspaces ou de fora do Databricks. Consulte Governança e privilégios.
Requirements
- Um workspace do Databricks em uma região com suporte do Unity Gateway.
- Unity Catalog habilitado para seu workspace. Consulte Ativar um workspace para o Unity Catalog.
- Para criar um serviço de modelo, você deve ter:
USE CATALOG,USE SCHEMAeCREATE SERVICEno catálogo e no esquema em que você cria o serviço de modelo.EXECUTEem cada modelo ao qual o serviço de modelo faz referência como destino.EXECUTE,USE CATALOGeUSE SCHEMAem cada provedor de modelo que o serviço de modelo referencia como destino.USE CATALOG,USE SCHEMAeCREATE TABLEno catálogo e no esquema onde a tabela de inferência é criada, se você habilitar o registro em log de inferência.
Criar um serviço de modelo personalizado
Crie um serviço de modelo na interface do Unity Gateway ou no Explorador de Catálogos. Para criar um programaticamente, use a API REST, os SDKs do Databricks, a CLI do Databricks, o Terraform ou os Declarative Automation Bundles (DABs).
Os serviços de modelos e os provedores de modelos compartilham um único namespace em um esquema do Unity Catalog. Você não pode usar um nome para um serviço de modelo se um provedor de modelos no esquema já o estiver usando, e vice-versa.
- UI
- REST API
- CLI
- Terraform
- DABs (Beta)
- Python SDK
- Go SDK
- Go Modular SDK
- Java SDK
- JS Modular SDK
-
Siga um destes procedimentos:
- Na barra lateral do workspace, clique em AI Gateway e, em seguida, em Create .
- No Catalog Explorer, vá para o esquema onde deseja criar o serviço de modelo e clique em Create > Service > Model service .
-
Insira um nome para o serviço de modelo e selecione o catálogo e o esquema em que deseja criá-lo. Se você começar a partir do Explorador de Catálogos, o Explorador de Catálogos preenche previamente o catálogo e o esquema.
-
Selecione o destino principal a ser atendido. Esse destino pode ser um modelo atendido pelo Databricks no qual você
EXECUTEe que o Unity Gateway pode atender, ou um provedor de modelo no qual vocêEXECUTE,USE CATALOGeUSE SCHEMA. -
Clique em Criar .
Após criar o serviço de modelo, o Databricks abre a página de visão geral dele, onde você pode começar a usar ou configurar recursos adicionais, como registro em log de inferência.
Envie um POST para /api/2.1/unity-catalog/model-services, passando parent e model_service_id como parâmetros de query. A configuração de roteamento deve ter pelo menos um destino:
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
}
]
}
}
}'
Passe o esquema pai e um nome folha, e forneça a configuração com --json. A configuração de roteamento deve ter pelo menos um destino. Para instalar a CLI, consulte Instalar ou atualizar a CLI do Databricks.
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
}
]
}
}
}'
Crie e gerencie um serviço de modelo com o Databricks Terraform provider e o recurso databricks_ai_gateway_model_service:
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
}]
}
}
}
Defina o serviço de modelo em um bundle e implante-o com databricks bundle deploy. A configuração de roteamento deve ter pelo menos um destino:
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
Crie e gerencie um serviço de modelo com o Databricks SDK for 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,
)
]
)
),
),
)
Crie e gerencie um serviço de modelo com o SDK do Databricks para 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,
}},
},
},
},
})
Crie e gerencie um serviço de modelo com o SDK do Databricks AI Gateway para Go. Campos opcionais são ponteiros, portanto, o exemplo usa um auxiliar de uma linha, 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"),
},
},
}},
},
},
},
})
Crie e gerencie um serviço de modelo com o SDK do Databricks para 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)));
Crie e gerencie um serviço de modelo com o Databricks AI Gateway SDK for 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,
},
],
},
},
},
});
Conceder acesso a um serviço de modelo
Por default, apenas o proprietário do serviço de modelo pode fazer query nele. Para permitir que outros façam query em um serviço de modelo, conceda a eles EXECUTE nele, além de USE CATALOG e USE SCHEMA em seu catálogo e esquema. Se o serviço de modelo fizer log em uma tabela de inferência, conceda SELECT na tabela para permitir que eles leiam as solicitações e respostas registradas.
- UI
- REST API
- CLI
- Terraform
- DABs (Beta)
- Python SDK
- Go SDK
- Java SDK
- Abra o serviço de modelo no Catalog Explorer ou vá para AI Gateway e selecione o serviço.
- Vá para a tab Permissions.
- Clique em Conceder .
- Selecione os usuários, grupos ou service principals para conceder acesso.
- Selecione o privilégio EXECUTE .
- Clique em Conceder .
databricks api patch \
"/api/2.1/unity-catalog/permissions/model_service/main.default.my_model_service" \
--json '{
"changes": [
{ "principal": "data-team", "add": ["EXECUTE"] }
]
}'
Conceda EXECUTE com a CLI do Databricks. Para instalar a CLI, consulte Instalar ou atualizar a CLI do Databricks.
databricks grants update model_service main.default.my_model_service \
--json '{"changes": [{"principal": "data-team", "add": ["EXECUTE"]}]}'
Conceda EXECUTE com o Databricks Terraform provider e o recurso databricks_grant:
resource "databricks_grant" "example" {
model_service = "main.default.my_model_service"
principal = "data-team"
privileges = ["EXECUTE"]
}
Adicione um bloco grants ao recurso de serviço de modelo no seu pacote e faça um novo deploy para conceder acesso.
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]
Conceda EXECUTE com o SDK do Databricks para 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])],
)
Conceda a EXECUTE o Databricks SDK for 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},
}},
})
Conceda EXECUTE com o Databricks SDK para 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)))));
Consulte Descobrir e governar o acesso a serviços de modelo para obter mais informações sobre como conceder e descobrir acesso.
Configurar recursos em um serviço de modelo
Configure limites de taxa, registro de inferência e salvaguardas implementadas com políticas de serviço no serviço de modelo na interface do Unity Gateway. Consulte:
- Aplicar limites de taxa a serviços de modelo e de MCP
- Logs solicitações e respostas em tabelas de inferência
Registro de inferência
Quando você ativa o registro de log de inferência, o Databricks cria uma nova tabela vazia do Unity Catalog com um esquema predefinido no local especificado por você. Observe o seguinte:
- Você deve ter
USE CATALOG,USE SCHEMAeCREATE TABLEno catálogo e no esquema de destino. - O criador do serviço de modelo é o proprietário da tabela de inferência. Nenhum outro usuário tem acesso, a menos que você o conceda.
- Se já existir uma tabela no local especificado, a criação do serviço de modelo falhará.
- A tabela de inferência tem um ciclo de vida independente do serviço de modelo. Se você excluir a tabela, o serviço de modelo continuará funcionando, mas interromperá o registro em log.
Para obter mais informações sobre tabelas de inferência, consulte Logs de solicitações e respostas em tabelas de inferência.
Atualizar um serviço do modelo
Você deve ser um proprietário ou ter MANAGE.
- UI
- REST API
- CLI
- Terraform
- DABs (Beta)
- Python SDK
- Go SDK
- Go Modular SDK
- Java SDK
- JS Modular SDK
Edite a configuração do serviço de modelo na interface de usuário do Unity Gateway ou no Catalog Explorer. As alterações são aplicadas no local.
databricks api patch \
"/api/2.1/unity-catalog/model-services/main.default.my_model_service?update_mask=comment" \
--json '{"comment": "Updated: routes chat traffic"}'
databricks ai-gateway update-model-service model-services/main.default.my_model_service comment \
--json '{"comment": "Updated: routes chat traffic"}'
Edite comment (ou qualquer outro campo mutável) no recurso databricks_ai_gateway_model_service e reaplique. As alterações são aplicadas no local.
Edite comment (ou qualquer outro campo mutável) no recurso do bundle e execute databricks bundle deploy. As alterações são aplicadas no local.
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"),
)
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"},
})
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,
})
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")));
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'),
});
Excluir um serviço de modelo
Você deve ser um proprietário ou ter MANAGE. Serviços de modelo fornecidos pelo sistema em system.ai não podem ser excluídos.
- UI
- REST API
- CLI
- Terraform
- DABs (Beta)
- Python SDK
- Go SDK
- Go Modular SDK
- Java SDK
- JS Modular SDK
Abra o serviço de modelo na interface do Unity Gateway ou no Catalog Explorer e selecione Excluir no menu do ícone de três pontos.
databricks api delete "/api/2.1/unity-catalog/model-services/main.default.my_model_service"
databricks ai-gateway delete-model-service model-services/main.default.my_model_service
Execute terraform destroy ou remova o bloco de recurso e aplique novamente.
Remova o recurso do pacote e execute databricks bundle deploy para excluí-lo. databricks bundle destroy também funciona, mas remove todos os recursos que o pacote gerencia, não apenas este.
w.ai_gateway.delete_model_service(name="model-services/main.default.my_model_service")
err := w.AiGateway.DeleteModelService(ctx, catalog.DeleteModelServiceRequest{
Name: "model-services/main.default.my_model_service",
})
err := c.DeleteModelService(ctx, aigateway.DeleteModelServiceRequest{
Name: ptr("model-services/main.default.my_model_service"),
})
w.aiGateway()
.deleteModelService(
new DeleteModelServiceRequest().setName("model-services/main.default.my_model_service"));
await client.deleteModelService({ name: 'model-services/main.default.my_model_service' });
Governança e privilégios
Como um objeto protegível do Unity Catalog, um serviço de modelo:
- Reside em um catálogo e esquema , onde herda as configurações do esquema, como vinculações de workspace.
- Contém metadados padrão do Unity Catalog , como nome, proprietário, comentário e tags.
- É governado por privilégios do Unity Catalog , então você concede acesso usando as mesmas declarações
GRANTeREVOKEque você usa para tabelas, funções e modelos. - É detectável no Catalog Explorer , juntamente com o restante dos seus ativos do Unity Catalog.
Os seguintes privilégios se aplicam:
Privilégio | Descrição |
|---|---|
| Acesse o catálogo e o esquema que contêm o serviço de modelo. Necessário para todas as operações. |
| Crie serviços de modelo em um esquema. Concedido no catálogo ou esquema. |
| Consultar um serviço de modelo. |
| Modificar ou excluir um serviço de modelo e gerenciar suas concessões. O proprietário tem um superconjunto de |
Os serviços de modelo usam privilégios do definidor. O Databricks avalia uma query com base nos privilégios do proprietário em vez dos privilégios de quem a chamou. Quando um usuário faz uma query em um serviço de modelo, o Databricks verifica se o proprietário tem EXECUTE nos destinos referenciados, como os modelos subjacentes e quaisquer provedores de modelo. O chamador não precisa ter acesso direto a esses destinos.
Limitações
Os seguintes recursos não são suportados:
- Criando e gerenciando serviços de modelo com SQL.
- Descoberta de serviços de modelo com apenas o privilégio
BROWSE. - Pesquisa global por serviços de modelo.