Nota
O acesso a esta página requer autorização. Pode tentar iniciar sessão ou alterar os diretórios.
O acesso a esta página requer autorização. Pode tentar alterar os diretórios.
Aprenda a registar um fornecedor como serviço modelo de fornecedor, conceder acesso a ele, configurar funcionalidades do Unity Gateway e eliminá-lo.
Requirements
-
CREATE SERVICEno esquema onde cria o serviço do fornecedor do modelo, maisUSE CATALOGeUSE SCHEMAno respetivo catálogo e esquema. - As credenciais do fornecedor externo que pretende registar (por exemplo, uma chave API OpenAI ou um par de chaves de acesso AWS).
- Para autenticar o Azure OpenAI ou o Microsoft Foundry com uma credencial de serviço em vez de uma chave ou segredo, deve ter uma credencial de serviço existente e
ACCESSnela. Veja Autenticar Azure OpenAI ou Microsoft Foundry com credencial de serviço.
Para associar uma credencial de fornecedor a um segredo do Unity Catalog detido pelo cliente, em vez de armazenar o valor diretamente, tem de ter um segredo existente do Unity Catalog e READ SECRET nesse segredo.
Consulte Credencial de fornecedor com base num segredo do Unity Catalog.
Criar um serviço modelo de prestador
Os serviços do fornecedor de modelos e os serviços de modelo partilham um único namespace dentro de um esquema do Catálogo Unity. Não podes usar um nome para um serviço de prestador modelo se um serviço modelo no esquema já o usar, e vice-versa.
Crie um serviço de fornecedor modelo na interface do Unity Gateway ou no Explorador de Catálogos. Para criar um programaticamente, use a API REST, os SDKs do Azure Databricks, a CLI do Databricks, o Terraform ou os Pacotes de Automação Declarativa (DABs).
IU
- Proceda de uma das seguintes formas:
- Na barra lateral do espaço de trabalho, clique em Unity Gateway, depois abra o separador Providers e clique em Provider.
- No Explorador de Catálogo, vá ao esquema onde quer criar o serviço de fornecedor de modelo, clique em Criar>Serviço e depois selecione Serviço de Modelo de Fornecedor na janela de diálogo Criar um serviço .
- Introduza um nome para o serviço de fornecedor de modelos e selecione o catálogo e o esquema onde o pretende criar. Se começares pelo Explorador de Catálogos, o Explorador de Catálogos prepreenche o catálogo e o esquema.
- Selecione o tipo de prestador e insira os dados e credenciais da ligação do fornecedor.
- Clique em Criar. Azure Databricks encripta e armazena as credenciais. A interface deixa de os mostrar a partir deste ponto.
API REST
Envie um POST para /api/2.1/unity-catalog/model-provider-services, passando parent e model_provider_service_id como parâmetros de consulta. definir provider_type e exatamente um bloco de fornecedor correspondente; targets permite listar os modelos a montante acessíveis, e os segredos são fornecidos em linha como texto simples:
databricks api post \
"/api/2.1/unity-catalog/model-provider-services?parent=schemas/main.default&model_provider_service_id=my_provider" \
--json '{
"comment": "Routes to a custom OpenAI-compatible provider",
"config": {
"provider_type": "EXTERNAL_MODEL_PROVIDER_TYPE_CUSTOM",
"targets": [
{ "model": "gpt-4o", "native_api_types": ["openai/v1/chat/completions"] }
],
"custom": {
"direct": {
"base_url": "https://api.example.com/v1",
"api_key": { "plaintext": "dummy-api-key" }
}
}
}
}'
CLI
Passe o esquema pai e um nome da folha, e forneça a configuração com --json. Defina provider_type e exatamente um bloco de prestador correspondente; targets define uma lista de permissões dos modelos de origem acessíveis, e os segredos são fornecidos inline em texto simples. Para instalar a linha de código, consulte Instalar ou atualizar a CLI de Databricks.
databricks ai-gateway create-model-provider-service schemas/main.default my_provider --json '{
"comment": "Routes to a custom OpenAI-compatible provider",
"config": {
"provider_type": "EXTERNAL_MODEL_PROVIDER_TYPE_CUSTOM",
"targets": [
{ "model": "gpt-4o", "native_api_types": ["openai/v1/chat/completions"] }
],
"custom": {
"direct": {
"base_url": "https://api.example.com/v1",
"api_key": { "plaintext": "dummy-api-key" }
}
}
}
}'
Terraform
Crie e gere um serviço de fornecedor de modelos com o fornecedor Databricks Terraform e o recurso databricks_ai_gateway_model_provider_service . Mantenha as chaves reais fora do controlo de código-fonte ao passar a chave da API através de uma variável sensitive = true (defina-a com -var ou uma variável de ambiente TF_VAR_provider_api_key):
variable "provider_api_key" {
type = string
sensitive = true
}
resource "databricks_ai_gateway_model_provider_service" "example" {
parent = "schemas/main.default"
model_provider_service_id = "my_provider"
comment = "Routes to a custom OpenAI-compatible provider"
config = {
provider_type = "EXTERNAL_MODEL_PROVIDER_TYPE_CUSTOM"
targets = [{
model = "gpt-4o"
native_api_types = ["openai/v1/chat/completions"]
}]
custom = {
direct = {
base_url = "https://api.example.com/v1"
api_key = { plaintext = var.provider_api_key }
}
}
}
}
DABs (Beta)
Defina o serviço do fornecedor modelo num bundle e implemente-o com databricks bundle deploy. Mantenha as chaves reais da API fora do controlo do código-fonte, ao passar a chave da API através de uma variável de bundle (defina-a com --var ou com uma variável de ambiente BUNDLE_VAR_provider_api_key):
variables:
provider_api_key:
description: Provider API key.
resources:
model_provider_services:
my_provider:
parent: schemas/main.default
model_provider_service_id: my_provider
comment: Routes to a custom OpenAI-compatible provider
config:
provider_type: EXTERNAL_MODEL_PROVIDER_TYPE_CUSTOM
targets:
- model: gpt-4o
native_api_types: [openai/v1/chat/completions]
custom:
direct:
base_url: https://api.example.com/v1
api_key:
plaintext: ${var.provider_api_key}
Python SDK
Criar e gerir um serviço de fornecedor de modelos com o SDK Databricks para Python:
from databricks.sdk.service import catalog as c
model_provider_service = w.ai_gateway.create_model_provider_service(
parent="schemas/main.default",
model_provider_service_id="my_provider",
model_provider_service=c.ModelProviderService(
comment="Routes to a custom OpenAI-compatible provider",
config=c.ModelProviderServiceConfig(
provider_type=(
c.ModelProviderServiceConfigExternalModelProviderType
.EXTERNAL_MODEL_PROVIDER_TYPE_CUSTOM
),
targets=[
c.ModelProviderServiceConfigModelTargetConfig(
model="gpt-4o",
native_api_types=["openai/v1/chat/completions"],
)
],
custom=c.ModelProviderServiceConfigCustomProviderConfig(
direct=c.ModelProviderServiceConfigCustomProviderDirectConfig(
base_url="https://api.example.com/v1",
api_key=c.ModelProviderServiceConfigProviderSecret(
plaintext="dummy-api-key"
),
)
),
),
),
)
Kit de Desenvolvimento de Software Go
Crie e gere um serviço de fornecedor modelo com o SDK Databricks para Go:
modelProviderService, err := w.AiGateway.CreateModelProviderService(ctx,
catalog.CreateModelProviderServiceRequest{
Parent: "schemas/main.default",
ModelProviderServiceId: "my_provider",
ModelProviderService: catalog.ModelProviderService{
Comment: "Routes to a custom OpenAI-compatible provider",
Config: &catalog.ModelProviderServiceConfig{
ProviderType: catalog.ModelProviderServiceConfigExternalModelProviderTypeExternalModelProviderTypeCustom,
Targets: []catalog.ModelProviderServiceConfigModelTargetConfig{{
Model: "gpt-4o",
NativeApiTypes: []string{"openai/v1/chat/completions"},
}},
Custom: &catalog.ModelProviderServiceConfigCustomProviderConfig{
Direct: &catalog.ModelProviderServiceConfigCustomProviderDirectConfig{
BaseUrl: "https://api.example.com/v1",
ApiKey: &catalog.ModelProviderServiceConfigProviderSecret{
Plaintext: "dummy-api-key",
},
},
},
},
},
})
Go Modular SDK
Crie e gere um serviço de fornecedor de modelos com o pacote Go SDK. Campos opcionais são ponteiros, por isso o exemplo usa uma função auxiliar de uma linha, func ptr[T any](v T) *T { return &v }.
modelProviderService, err := c.CreateModelProviderService(ctx,
aigateway.CreateModelProviderServiceRequest{
Parent: ptr("schemas/main.default"),
ModelProviderServiceId: ptr("my_provider"),
ModelProviderService: &aigateway.ModelProviderService{
Comment: ptr("Routes to a custom OpenAI-compatible provider"),
Config: &aigateway.ModelProviderServiceConfig{
ProviderType: aigateway.ModelProviderServiceConfig_ExternalModelProviderType_ExternalModelProviderTypeCustom,
Targets: []aigateway.ModelProviderServiceConfig_ModelTargetConfig{{
Model: ptr("gpt-4o"),
NativeApiTypes: []string{"openai/v1/chat/completions"},
}},
Provider: &aigateway.ModelProviderServiceConfig_Provider_Custom{
Custom: aigateway.ModelProviderServiceConfig_CustomProviderConfig{
ProviderMode: &aigateway.ModelProviderServiceConfig_CustomProviderConfig_ProviderMode_Direct{
Direct: aigateway.ModelProviderServiceConfig_CustomProviderDirectConfig{
BaseUrl: ptr("https://api.example.com/v1"),
AuthMode: &aigateway.ModelProviderServiceConfig_CustomProviderDirectConfig_AuthMode_ApiKey{
ApiKey: aigateway.ModelProviderServiceConfig_ProviderSecret{
Value: &aigateway.ModelProviderServiceConfig_ProviderSecret_Value_Plaintext{
Plaintext: "dummy-api-key",
},
},
},
},
},
},
},
},
},
})
SDK de Java
Crie e gere um serviço de fornecedor de modelos com o SDK Databricks para Java:
ModelProviderServiceConfig config =
new ModelProviderServiceConfig()
.setProviderType(
ModelProviderServiceConfigExternalModelProviderType
.EXTERNAL_MODEL_PROVIDER_TYPE_CUSTOM)
.setTargets(
Collections.singletonList(
new ModelProviderServiceConfigModelTargetConfig()
.setModel("gpt-4o")
.setNativeApiTypes(
Collections.singletonList("openai/v1/chat/completions"))))
.setCustom(
new ModelProviderServiceConfigCustomProviderConfig()
.setDirect(
new ModelProviderServiceConfigCustomProviderDirectConfig()
.setBaseUrl("https://api.example.com/v1")
.setApiKey(
new ModelProviderServiceConfigProviderSecret()
.setPlaintext("dummy-api-key"))));
ModelProviderService modelProviderService =
w.aiGateway()
.createModelProviderService(
new CreateModelProviderServiceRequest()
.setParent("schemas/main.default")
.setModelProviderServiceId("my_provider")
.setModelProviderService(
new ModelProviderService()
.setComment("Routes to a custom OpenAI-compatible provider")
.setConfig(config)));
JS Modular SDK
Crie e gere um serviço de fornecedor de modelos com o pacote JavaScript SDK:
import { ModelProviderServiceConfig_ExternalModelProviderType as ProviderType } from '@databricks/sdk-aigateway/v1';
const created = await client.createModelProviderService({
parent: 'schemas/main.default',
modelProviderServiceId: 'my_provider',
modelProviderService: {
comment: 'Routes to a custom OpenAI-compatible provider',
config: {
providerType: ProviderType.EXTERNAL_MODEL_PROVIDER_TYPE_CUSTOM,
targets: [{ model: 'gpt-4o', nativeApiTypes: ['openai/v1/chat/completions'] }],
provider: {
$case: 'custom',
custom: {
providerMode: {
$case: 'direct',
direct: {
baseUrl: 'https://api.example.com/v1',
authMode: {
$case: 'apiKey',
apiKey: {
value: { $case: 'plaintext', plaintext: 'dummy-api-key' },
},
},
},
},
},
},
},
},
});
Para a lista completa de fornecedores e os seus métodos de autenticação, veja Fornecedores Modelo externos ao Databricks.
Autenticar Azure OpenAI ou Microsoft Foundry com uma credencial de serviço
Pode autenticar um fornecedor do Azure OpenAI ou do Microsoft Foundry com uma credencial de serviço, em vez de armazenar uma chave de API ou um segredo do cliente de uma entidade de serviço do Microsoft Entra ID. Uma credencial de serviço detém uma identidade Azure que o Unity Catalog governa, pelo que nenhum segredo duradouro é copiado para o serviço do fornecedor modelo: o Azure Databricks obtém tokens de curta duração dessa identidade para autenticar cada pedido.
Crie o serviço modelo de prestador conforme descrito em Criar um serviço modelo de prestador. Selecione Azure OpenAI ou Microsoft Foundry como tipo de fornecedor e introduza os detalhes da sua ligação, incluindo a URL base do endpoint. Depois, defina o método Auth como credencial de serviço e selecione a credencial em vez de introduzir uma chave API ou o segredo do cliente. Uma credencial de serviço substitui apenas o segredo, pelo que a URL base do endpoint continua a ser necessária.
Confirme os seguintes requisitos:
O proprietário do serviço do fornecedor do modelo tem
ACCESSna credencial de serviço. Como o Azure Databricks verifica novamente o acesso do proprietário ao atender pedidos, o proprietário deve mantê-lo enquanto o fornecedor estiver em uso. Revogá-lo impede consultas para todos, até para os autores das chamadas que tenhamEXECUTEno fornecedor. Para conceder ao proprietário acesso à credencial:GRANT ACCESS ON SERVICE CREDENTIAL <service-credential-name> TO `<model-provider-service-owner>`;O objetivo da credencial é o serviço, não o armazenamento.
A credencial está disponível nos espaços de trabalho de onde vêm os pedidos. Os seus vínculos ao espaço de trabalho continuam a aplicar-se, pelo que um pedido proveniente de um espaço de trabalho ao qual a credencial não está associada falha nesse espaço, embora o próprio serviço do fornecedor de modelos seja acessível a partir de qualquer espaço de trabalho que partilhe o metastore.
A identidade Azure da credencial de serviço está autorizada a contactar as implementações Azure OpenAI ou Microsoft Foundry que pretende consultar. Para criar uma credencial de serviço, consulte Criar credenciais de serviço.
Os que consultam o prestador necessitam das mesmas subvenções que para qualquer outro prestador. Eles não precisam de ter qualquer privilégio sobre a credencial de serviço, o que mantém a própria credencial fora do alcance deles.
O serviço do fornecedor do modelo identifica uma credencial pelo seu identificador interno, o que lhe permite renomear uma credencial sem que a consulta falhe.
Se apagar uma credencial, as consultas falham e não há qualquer aviso de que um serviço modelo de fornecedor a refere. Confirme que não há referências a esta credencial antes de a apagar.
Não se pode alternar um serviço de fornecedor modelo existente entre credencial de serviço e autenticação por chave API ou segredo do cliente. Crie um novo modelo de serviço de prestação em vez disso.
Envie uma chave API personalizada de fornecedor num cabeçalho
Um fornecedor personalizado envia a sua chave API como token portador por defeito. Quando o seu endpoint espera que a chave esteja num cabeçalho específico, use a autenticação do cabeçalho da chave API e nomeie o cabeçalho você mesmo. O Azure Databricks envia então a chave em cada pedido de saída como <header name>: <header value>.
Crie o serviço modelo de prestador conforme descrito em Criar um serviço modelo de prestador. Selecione Personalizado como tipo de fornecedor, depois defina o método Auth como cabeçalho da chave API e forneça o nome do Cabeçalho que o seu endpoint espera (como X-API-Key ou Ocp-Apim-Subscription-Key) juntamente com o valor do Cabeçalho.
Os dois métodos são mutuamente exclusivos: um fornecedor personalizado utiliza um token portador ou um cabeçalho nomeado, não ambos. A autenticação por cabeçalho requer exatamente um cabeçalho.
O nome do cabeçalho deve ser um nome de cabeçalho HTTP válido: letras, dígitos e os caracteres !#$%&'*+-.^_`|~, até 255 caracteres. Qualquer outro carácter não é aceite, incluindo espaços, dois-pontos, barras e quebras de linha.
Proteger uma credencial de fornecedor com um segredo no Unity Catalog
Em vez de armazenar diretamente uma credencial do fornecedor, pode apontar um serviço de fornecedor de modelos para um segredo do Unity Catalog pertencente ao cliente e que contém o valor. O Azure Databricks lê o segredo no momento da execução da consulta, utilizando as permissões de acesso do proprietário do serviço do fornecedor do modelo, e nunca copia o valor para o serviço do fornecedor do modelo, pelo que a rotação do segredo entra em vigor sem qualquer alteração no serviço do fornecedor do modelo.
Isto funciona para qualquer fornecedor cuja credencial seja um único valor inline: OpenAI, Azure OpenAI, Anthropic, Amazon Bedrock, Amazon Bedrock Mantle, Microsoft Foundry, Google Gemini Enterprise e Custom.
Crie o serviço modelo de prestador conforme descrito em Criar um serviço modelo de prestador. Selecione o tipo de fornecedor e introduza os seus dados de ligação. Para a credencial (como a chave API), altere o tipo de autenticação de Texto Simples para Secreto, depois selecione o catálogo, o esquema e o segredo que identificam o seu segredo do Catálogo Unity.
Confirme os seguintes requisitos:
O proprietário do serviço do fornecedor de modelos tem
READ SECRETo segredo do Catálogo Unity. Como o Azure Databricks verifica novamente o acesso do proprietário ao atender pedidos, o proprietário deve mantê-lo enquanto o fornecedor estiver em uso. Revogá-lo impede consultas para todos, até para os autores das chamadas que tenhamEXECUTEno fornecedor. Para conceder ao proprietário acesso ao segredo:GRANT READ SECRET ON SECRET <catalog>.<schema>.<secret> TO `<model-provider-service-owner>`;O segredo do Catálogo Unity existe antes de o referenciares. Para criar e governar segredos do Catálogo Unity, consulte Segredos no Catálogo Unity.
Os que consultam o prestador necessitam das mesmas subvenções que para qualquer outro prestador. Eles não precisam de nenhum privilégio sobre o segredo do Unity Catalog, que é o que mantém o valor secreto fora do seu alcance.
Para efetuar a rotação da credencial, atualize o valor do segredo do Unity Catalog, sem qualquer alteração ao serviço do fornecedor do modelo.
Se apagares o segredo do Unity Catalog, as consultas falham. O serviço do fornecedor do modelo mantém a referência, agora inválida, para que possas ver a dependência, e podes restaurar o fornecedor atualizando-o para referenciar um segredo que ainda existe.
Eliminar um serviço de fornecedor de modelos nunca elimina o segredo do Unity Catalog ao qual faz referência.
Conceder acesso a um serviço modelo de prestador
Por predefinição, apenas o proprietário do serviço do fornecedor do modelo pode consultá-lo. Para permitir que outros consultem um serviço de fornecedor de modelos, concede-lhes EXECUTE sobre esse serviço, bem como USE CATALOG e USE SCHEMA sobre o respetivo catálogo e esquema. Se o serviço do fornecedor do modelo registar uma tabela de inferência, conceda SELECT à tabela que lhes permita ler os pedidos e respostas registados.
IU
- Abra o serviço do fornecedor do modelo no Explorador de Catálogos, ou vá para o Unity Gateway e selecione o serviço.
- Vá para a guia Permissões .
- Clique em Conceder.
- Selecione os utilizadores, grupos ou identidades de serviço a quem pretende conceder acesso.
- Selecione o privilégio EXECUTE.
- Clique em Conceder.
API REST
databricks api patch \
"/api/2.1/unity-catalog/permissions/model_provider_service/main.default.my_provider" \
--json '{
"changes": [
{ "principal": "data-team", "add": ["EXECUTE"] }
]
}'
CLI
Grant EXECUTE com a linha de comando do Databricks. Para instalar a linha de código, consulte Instalar ou atualizar a CLI de Databricks.
databricks grants update model_provider_service main.default.my_provider \
--json '{"changes": [{"principal": "data-team", "add": ["EXECUTE"]}]}'
Terraform
Subvenção EXECUTE com o fornecedor Databricks Terraform e o databricks_grant recurso:
resource "databricks_grant" "example" {
model_provider_service = "main.default.my_provider"
principal = "data-team"
privileges = ["EXECUTE"]
}
DABs (Beta)
Adicione um grants bloco ao recurso de serviço do fornecedor modelo no seu pacote e reimplemente para conceder acesso.
variables:
provider_api_key:
description: Provider API key.
resources:
model_provider_services:
my_provider:
parent: schemas/main.default
model_provider_service_id: my_provider
comment: Routes to a custom OpenAI-compatible provider
config:
provider_type: EXTERNAL_MODEL_PROVIDER_TYPE_CUSTOM
targets:
- model: gpt-4o
native_api_types: [openai/v1/chat/completions]
custom:
direct:
base_url: https://api.example.com/v1
api_key:
plaintext: ${var.provider_api_key}
grants:
- principal: data-team
privileges: [EXECUTE]
Python SDK
Subvenção EXECUTE com o SDK Databricks para Python:
from databricks.sdk.service import catalog as c
w.grants.update(
securable_type="model_provider_service",
full_name="main.default.my_provider",
changes=[c.PermissionsChange(principal="data-team", add=[c.Privilege.EXECUTE])],
)
Kit de Desenvolvimento de Software Go
Grant EXECUTE com o SDK Databricks para Go:
_, err := w.Grants.Update(ctx, catalog.UpdatePermissions{
SecurableType: "model_provider_service",
FullName: "main.default.my_provider",
Changes: []catalog.PermissionsChange{{
Principal: "data-team",
Add: []catalog.Privilege{catalog.PrivilegeExecute},
}},
})
SDK de Java
Grant EXECUTE com o SDK Databricks para Java:
w.grants().update(
new UpdatePermissions()
.setSecurableType("model_provider_service")
.setFullName("main.default.my_provider")
.setChanges(Arrays.asList(
new PermissionsChange().setPrincipal("data-team").setAdd(Arrays.asList(Privilege.EXECUTE)))));
Para mais informações sobre conceder e descobrir acesso, consulte Descobrir e regular o acesso a fornecedores modelo externos (serviços modelo de fornecedores).
Configurar recursos
Uma vez que um serviço de fornecedor de modelos encaminha o tráfego através do Unity Gateway, aplique as mesmas funcionalidades de governação e observabilidade que utiliza para outro tráfego do Unity Gateway:
- Registo de inferências. Registe pedidos e respostas numa tabela do Unity Catalog. Ver Pedidos de registo e respostas às tabelas de inferência.
- Limites de taxa. Limite as consultas por minuto para gerir a capacidade e o custo. Consulte Aplicar limites de taxa a serviços modelo e MCP.
- Políticas de serviço. Regule o conteúdo de cada interação, como bloquear conteúdos inseguros ou redigir dados sensíveis, anexando uma política de serviço. Consulte Políticas de serviço para itens protegíveis de IA e Criar e anexar uma política de serviço.
Configure um multiplicador de preços
Por defeito, o Azure Databricks estima os custos com modelos externos com base nos preços de tabela publicados pelo fornecedor. Se o preço do seu fornecedor for diferente, configure um multiplicador de preços para refletir descontos ou margens. Por exemplo, 0.8 usa 80% do preço de lista, enquanto 1.2 usa 120%.
- Crie um serviço de fornecedor de modelos, ou abra um serviço de fornecedor de modelos existente no Explorador de Catálogos ou no Unity Gateway e clique em Editar.
- Expanda Opções avançadas.
- Introduza um multiplicador do preço.
- Clique em Criar ou Guardar.
O multiplicador aplica-se a todos os modelos disponíveis através do serviço de fornecedor de modelos. O gasto calculado em system.ai_gateway.external_model_spend reflete o multiplicador configurado. As alterações aplicam-se a pedidos feitos após a entrada em vigor da configuração; os pedidos anteriores mantêm-se estimados usando o preço de tabela ou o multiplicador previamente configurado.
Um multiplicador configurado mostra uma etiqueta de Preço Personalizada . Os preços ajustados têm um sublinhado tracejado nas tabelas de preços. Passe o rato sobre um preço ajustado para comparar o preço ajustado com o preço de tabela do fornecedor.
Configurar rotas de endpoint para um fornecedor personalizado
As rotas de endpoint são opcionais. Utilize-os quando um fornecedor personalizado hospeda modelos diferentes em caminhos diferentes sob o mesmo base_url. Um modelo pode suportar múltiplos tipos de API. Cada modelo tem uma rota de endpoint partilhada pelos seus tipos de API suportados.
Para configurar uma rota, defina endpoint_route no destino para um caminho relativo, não um URL completo. O Unity Gateway adiciona a rota ao final de base_url, após qualquer caminho que base_url já contenha.
IU
- Abra o diálogo Criar serviço de prestador de modelos conforme descrito em Criar um serviço de prestador de modelos e selecione Personalizado na secção Prestador.
- Na secção Modelos, introduza um nome de modelo, selecione os tipos de API que esse modelo serve e introduza um caminho relativo na rota Endpoint (opcional).
- Clique em Adicionar modelo. Repita para cada modelo.
- Clique em Criar.
API REST
O pedido seguinte configura rotas separadas para um modelo de chat e um modelo de embedding:
databricks api post \
"/api/2.1/unity-catalog/model-provider-services?parent=schemas/main.default&model_provider_service_id=my_provider" \
--json '{
"config": {
"provider_type": "EXTERNAL_MODEL_PROVIDER_TYPE_CUSTOM",
"targets": [
{
"model": "chat-model",
"native_api_types": ["openai/v1/chat/completions"],
"endpoint_route": "serve/openai/chat"
},
{
"model": "embedding-model",
"native_api_types": ["openai/v1/embeddings"],
"endpoint_route": "serve/openai/embed"
}
],
"custom": {
"direct": {
"base_url": "https://api.example.com/gateway",
"api_key": { "plaintext": "placeholder-api-key" }
}
}
}
}'
Com isto base_url, os pedidos utilizam as seguintes URLs upstream:
-
chat-model:https://api.example.com/gateway/serve/openai/chat -
embedding-model:https://api.example.com/gateway/serve/openai/embed
Se omitires endpoint_route ou definires uma string vazia, o Unity Gateway usa o base_url inalterado.
native_api_types seleciona a tradução API para cada modelo. Não seleciona nem altera a rota a montante.
Atualizar um serviço modelo de fornecedor
Deve ser proprietário ou ter MANAGE. O tipo de fornecedor é imutável.
IU
Edite a configuração do serviço do fornecedor de modelos a partir da interface do Unity Gateway ou do Explorador de Catálogos. As alterações aplicam-se no local.
API REST
databricks api patch \
"/api/2.1/unity-catalog/model-provider-services/main.default.my_provider?update_mask=comment" \
--json '{"comment": "Updated: routes to a custom provider"}'
CLI
databricks ai-gateway update-model-provider-service model-provider-services/main.default.my_provider comment \
--json '{"comment": "Updated: routes to a custom provider"}'
Terraform
Edita comment (ou qualquer outro campo mutável) no databricks_ai_gateway_model_provider_service recurso e volta a aplicar. As alterações aplicam-se no local.
DABs (Beta)
Edite comment (ou qualquer outro campo mutável) no recurso bundle e execute databricks bundle deploy. As alterações aplicam-se no local.
Python SDK
from databricks.sdk.service import catalog as c
from google.protobuf.field_mask_pb2 import FieldMask
updated = w.ai_gateway.update_model_provider_service(
name="model-provider-services/main.default.my_provider",
update_mask=FieldMask(paths=["comment"]),
model_provider_service=c.ModelProviderService(
comment="Updated: routes to a custom provider"
),
)
Kit de Desenvolvimento de Software Go
updated, err := w.AiGateway.UpdateModelProviderService(ctx,
catalog.UpdateModelProviderServiceRequest{
Name: "model-provider-services/main.default.my_provider",
UpdateMask: *fieldmask.New([]string{"comment"}),
ModelProviderService: catalog.ModelProviderService{
Comment: "Updated: routes to a custom provider",
},
})
Go Modular SDK
mask, err := types.NewFieldMask[aigateway.ModelProviderService]("comment")
updated, err := c.UpdateModelProviderService(ctx,
aigateway.UpdateModelProviderServiceRequest{
ModelProviderService: &aigateway.ModelProviderService{
Name: ptr("model-provider-services/main.default.my_provider"),
Comment: ptr("Updated: routes to a custom provider"),
},
UpdateMask: mask,
})
SDK de Java
ModelProviderService updated =
w.aiGateway()
.updateModelProviderService(
new UpdateModelProviderServiceRequest()
.setName("model-provider-services/main.default.my_provider")
.setUpdateMask(FieldMask.newBuilder().addPaths("comment").build())
.setModelProviderService(
new ModelProviderService()
.setComment("Updated: routes to a custom provider")));
JS Modular SDK
import { modelProviderServiceFieldMask } from '@databricks/sdk-aigateway/v1';
const updated = await client.updateModelProviderService({
modelProviderService: {
name: 'model-provider-services/main.default.my_provider',
comment: 'Updated: routes to a custom provider',
},
updateMask: modelProviderServiceFieldMask('comment'),
});
Eliminar um serviço de prestador modelo
Deve ser proprietário ou ter MANAGE.
IU
Abra o serviço do fornecedor de modelos na interface do Unity Gateway ou no Explorador de Catálogos e selecione Eliminar no menu kebab.
API REST
databricks api delete "/api/2.1/unity-catalog/model-provider-services/main.default.my_provider"
CLI
databricks ai-gateway delete-model-provider-service model-provider-services/main.default.my_provider
Terraform
Executa terraform destroy, ou remove o bloco de recurso e volta a aplicar.
DABs (Beta)
Remova o recurso do pacote e execute databricks bundle deploy para o eliminar.
databricks bundle destroy Também funciona, mas remove todos os recursos que o pacote gere, não apenas este.
Python SDK
w.ai_gateway.delete_model_provider_service(
name="model-provider-services/main.default.my_provider"
)
Kit de Desenvolvimento de Software Go
err := w.AiGateway.DeleteModelProviderService(ctx,
catalog.DeleteModelProviderServiceRequest{
Name: "model-provider-services/main.default.my_provider",
})
Go Modular SDK
err := c.DeleteModelProviderService(ctx,
aigateway.DeleteModelProviderServiceRequest{
Name: ptr("model-provider-services/main.default.my_provider"),
})
SDK de Java
w.aiGateway()
.deleteModelProviderService(
new DeleteModelProviderServiceRequest()
.setName("model-provider-services/main.default.my_provider"));
JS Modular SDK
await client.deleteModelProviderService({
name: 'model-provider-services/main.default.my_provider',
});