Nota:
El acceso a esta página requiere autorización. Puede intentar iniciar sesión o cambiar directorios.
El acceso a esta página requiere autorización. Puede intentar cambiar los directorios.
Aprende a registrar un proveedor como servicio modelo de proveedor, concederle acceso, configurar funciones de Unity Gateway y eliminarlo.
Requirements
-
CREATE SERVICEen el esquema donde creas el servicio del proveedor de modelos, además deUSE CATALOGyUSE SCHEMAen su catálogo y esquema. - Las credenciales del proveedor externo que desea registrar (por ejemplo, una clave de API de OpenAI o un par de claves de acceso de AWS).
- Para autenticarse en Azure OpenAI o Microsoft Foundry con una credencial de servicio en lugar de una clave o un secreto, debe tener una credencial de servicio existente y
ACCESS. Consulta Autenticar Azure OpenAI o Microsoft Foundry con credencial de servicio.
Para respaldar las credenciales de un proveedor con un secreto de Unity Catalog propiedad del cliente, en lugar de almacenar el valor en línea, debe disponer de un secreto de Unity Catalog existente y READ SECRET sobre él. Consulta Respaldar una credencial de proveedor con un secreto de Unity Catalog.
Crear un servicio de proveedor de modelos
Los servicios de proveedor de modelos y los servicios de modelo comparten un único espacio de nombres dentro de un esquema de catálogo de Unity. No puede usar un nombre para un servicio de proveedor de modelos si ya lo usa un servicio de modelo en el esquema y viceversa.
Crea un servicio de proveedor modelo en la interfaz de usuario de Unity Gateway o en el Explorador de catálogos. Para crear uno programáticamente, utiliza la API REST, los SDKs de Azure Databricks, la CLI de Databricks, Terraform o los Bundles de Automatización Declarativa (DABs).
Interfaz de usuario
- Realice una de las acciones siguientes:
- En la barra lateral del espacio de trabajo, haz clic en Unity Gateway, luego abre la pestaña de Proveedores y haz clic en Proveedor.
- En el Explorador de Catálogo, ve al esquema donde quieres crear el servicio proveedor de modelos, haz clic en Crear>servicio y luego selecciona Servicio de proveedor de modelo en el cuadro de diálogo Crear un servicio .
- Escriba un nombre para el servicio de proveedor de modelos y seleccione el catálogo y el esquema en los que se va a crear. Si empieza desde el Explorador de catálogos, el Explorador de catálogos rellena previamente el catálogo y el esquema.
- Seleccione el tipo de proveedor y escriba los detalles y las credenciales de conexión del proveedor.
- Haga clic en Crear. Azure Databricks cifra y almacena las credenciales. La interfaz de usuario no las muestra después de este punto.
REST API
Envía un POST a /api/2.1/unity-catalog/model-provider-services, pasando parent y model_provider_service_id como parámetros de consulta. Establece provider_type y exactamente un bloque de proveedor coincidente; targets incluye en la lista de permitidos los modelos de origen accesibles, y los secretos se proporcionan en línea como texto sin cifrar:
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
Pasa el esquema padre y un nombre de nodo hoja, y proporciona la configuración con --json. establecen provider_type y exactamente un bloque de proveedor coincidente; targets permite listar los modelos ascendentes accesibles, y los secretos se suministran en línea como texto plano. Para instalar la línea de código, consulte Instalar o actualizar la 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
Crea y gestiona un servicio de proveedor modelo con el proveedor de Databricks Terraform y el recurso databricks_ai_gateway_model_provider_service . Mantén las claves reales fuera del control de versiones pasando la clave API a través de una sensitive = true variable (configúrala con -var o una TF_VAR_provider_api_key variable de entorno):
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)
Define el servicio proveedor modelo en un paquete y despláchalo con databricks bundle deploy. Mantén las claves reales fuera del control de versiones pasando la clave de API mediante una variable de paquete (configúrala con --var o una variable de entorno 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}
SDK de Python
Crea y gestiona un servicio proveedor de modelos con el 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 Desarrollo de Software Go
Crea y gestiona un servicio de proveedor modelo con el 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
Crea y gestiona un servicio de proveedor de modelos con el paquete Go SDK. Los campos opcionales son punteros, por lo que el ejemplo utiliza un asistente de una línea, 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
Crea y gestiona un servicio proveedor de modelos con el 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
Crea y gestiona un servicio de proveedor de modelos con el paquete 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 la lista completa de proveedores y sus métodos de autenticación, véase Proveedores modelo externos a Databricks.
Autentique Azure OpenAI o Microsoft Foundry con una credencial de servicio
Puedes autenticar a un proveedor de Azure, OpenAI o Microsoft Foundry con una credencial de servicio en lugar de almacenar una clave API o un secreto cliente principal de servicio Microsoft Entra ID. Una credencial de servicio tiene una identidad de Azure que Unity Catalog gobierna, por lo que no se copia ningún secreto duradero en el servicio modelo de proveedor: Azure Databricks obtiene tokens de corta duración de esa identidad para autenticar cada solicitud.
Crea el servicio de proveedor modelo tal como se describe en Crea un servicio de proveedor modelo. Selecciona Azure OpenAI o Microsoft Foundry como tipo de proveedor e introduce sus datos de conexión, incluyendo la URL base del endpoint. Luego configura el método de autenticación en credencial de servicio y selecciona la credencial en lugar de introducir una clave de API o un secreto cliente. Una credencial de servicio reemplaza solo al secreto, por lo que la URL base del endpoint sigue siendo necesaria.
Confirme los siguientes requisitos:
El propietario del servicio del proveedor del modelo tiene
ACCESSen la credencial del servicio. Como Azure Databricks vuelve a comprobar el acceso del propietario al atender las solicitudes, este debe conservarlo mientras el proveedor esté en uso. Revocarla detiene las consultas para todos, incluso para los usuarios que tienenEXECUTEsobre el proveedor. Para conceder al propietario acceso a la credencial:GRANT ACCESS ON SERVICE CREDENTIAL <service-credential-name> TO `<model-provider-service-owner>`;El propósito de la credencial es el servicio, no el almacenamiento.
La credencial está disponible en los espacios de trabajo de donde provienen las solicitudes. Sus vinculaciones al espacio de trabajo siguen siendo válidas, por lo que una solicitud procedente de un espacio de trabajo al que no esté vinculada la credencial fallará allí, aunque se pueda acceder al propio servicio de proveedor de modelos desde cualquier espacio de trabajo que comparta el metastore.
La identidad de Azure de la credencial del servicio está autorizada para invocar las implementaciones de Azure OpenAI o de Microsoft Foundry que tengas previsto consultar. Para crear una credencial de servicio, consulte Creación de credenciales de servicio.
Los que llaman al proveedor necesitan las mismas ayudas que cualquier otro proveedor. No necesitan ningún privilegio sobre la credencial de servicio, que es lo que mantiene la credencial fuera de su alcance.
El servicio del proveedor del modelo hace seguimiento de una credencial mediante su identificador interno, por lo que puedes cambiar el nombre de una credencial sin que la consulta falle.
Si eliminas una credencial, las consultas fallan y no hay aviso de que un servicio modelo de proveedor la mencione. Confirma que no hay referencias a esta credencial antes de eliminarla.
No puedes cambiar un servicio de proveedor modelo existente entre credenciales de servicio y clave API o autenticación secreta de cliente. Crea un nuevo modelo de servicio de proveedor en su lugar.
Envía una clave API personalizada de proveedor en una cabecera
Un proveedor personalizado envía su clave API como token portador por defecto. Si tu punto de conexión espera la clave en un encabezado específico, utiliza la autenticación mediante encabezado de clave de API y asigna tú mismo el nombre al encabezado. Azure Databricks envía entonces la clave en cada solicitud saliente como <header name>: <header value>.
Crea el servicio de proveedor modelo tal como se describe en Crea un servicio de proveedor modelo. Selecciona Personalizado como tipo de proveedor, luego establece el método Auth en encabezado de clave API y proporciona el nombre de encabezado que espera tu endpoint (como X-API-Key o Ocp-Apim-Subscription-Key) junto con el valor de cabecera.
Los dos métodos son mutuamente excluyentes: un proveedor personalizado utiliza un token de portador o un encabezado con nombre, no ambos. La autenticación mediante encabezado usa exactamente un encabezado.
El nombre del encabezado debe ser un nombre de cabecera HTTP válido: letras, dígitos y los caracteres !#$%&'*+-.^_`|~, hasta 255 caracteres. Se rechaza cualquier otro carácter, incluidos espacios, dos puntos, barras y saltos de línea.
Respalda una credencial de proveedor con un secreto del catálogo de Unity
En lugar de almacenar directamente una credencial de proveedor, puedes hacer que un servicio de proveedor de modelos apunte a un secreto de Unity Catalog que pertenece al cliente y contiene ese valor. Azure Databricks lee el secreto en el momento de la consulta bajo el acceso del propietario del servicio proveedor modelo y nunca copia el valor en el servicio proveedor modelo, por lo que rotar el secreto entra en vigor sin cambios en el servicio proveedor modelo.
Esto funciona para cualquier proveedor cuya credencial sea un único valor en línea: OpenAI, Azure OpenAI, Anthropic, Amazon Bedrock, Amazon Bedrock Mantle, Microsoft Foundry, Google Gemini Enterprise y Custom.
Crea el servicio de proveedor modelo tal como se describe en Crea un servicio de proveedor modelo. Selecciona el tipo de proveedor e introduce sus datos de conexión. Para la credencial (como la clave API), cambia el tipo de autenticación de Texto plano a Secreto, luego selecciona el catálogo, esquema y secreto que identifican tu secreto del Catálogo de Unity.
Confirme los siguientes requisitos:
El propietario del servicio de proveedor de modelos tiene
READ SECRETel secreto del Catálogo de Unity. Como Azure Databricks vuelve a comprobar el acceso del propietario al atender las solicitudes, este debe conservarlo mientras el proveedor esté en uso. Revocarla detiene las consultas para todos, incluso para los usuarios que tienenEXECUTEsobre el proveedor. Para conceder al propietario acceso al secreto:GRANT READ SECRET ON SECRET <catalog>.<schema>.<secret> TO `<model-provider-service-owner>`;Asegúrate de que el secreto de Unity Catalog exista antes de hacer referencia a él. Para crear y gobernar los secretos del Catálogo de Unity, consulte Secretos en el Catálogo de Unity.
Los que llaman al proveedor necesitan las mismas ayudas que cualquier otro proveedor. No necesitan ningún privilegio sobre el secreto de Unity Catalog, y precisamente eso es lo que mantiene el valor del secreto fuera de su alcance.
Para rotar la credencial, actualiza el valor del secreto de Unity Catalog, sin realizar cambios en el servicio del proveedor de modelos.
Si eliminas el secreto del Catálogo de Unity, las consultas fallan. El servicio de proveedor modelo mantiene la referencia ahora rota para que puedas ver la dependencia, y puedes restaurar el proveedor actualizándolo para que haga referencia a un secreto que aún existe.
Eliminar un servicio de proveedor de modelos nunca elimina el secreto de Unity Catalog al que hace referencia.
Utiliza la suscripción de Claude o ChatGPT de cada persona
En lugar de almacenar una clave API, un servicio de proveedor de modelos puede permitir que cada usuario use su propia suscripción de Claude o ChatGPT en un agente de codificación. El servicio no almacena ninguna credencial. Cada solicitante inicia sesión con su propia suscripción, y las solicitudes se facturan en función de ella.
Crea el servicio de proveedor modelo tal como se describe en Crear un servicio de proveedor modelo, luego selecciona el tipo de proveedor y el modo de autenticación:
- Claude: Selecciona Anthropic como tipo de proveedor y el modo de autenticación Claude Max / Enterprise. Para conectar Claude Code, consulta el soporte de Claude Max y Anthropic Enterprise.
- ChatGPT: Selecciona OpenAI como tipo de proveedor y el modo de autenticación planes ChatGPT Go / Plus / Pro / Enterprise. Para conectar Codex, consulta soporte por suscripción de ChatGPT.
Concede acceso a un servicio de proveedor modelo
Por defecto, solo el propietario del servicio del proveedor del modelo puede consultarlo. Para que otros puedan consultar un servicio de proveedor de modelos, concédeles EXECUTE sobre este, además de USE CATALOG y USE SCHEMA sobre su catálogo y su esquema. Si el servicio de proveedor de modelos registra información en una tabla de inferencia, concede el privilegio SELECT sobre la tabla para permitirle leer las solicitudes y respuestas registradas.
Interfaz de usuario
- Abre el servicio del proveedor de modelos en el Explorador de Catálogos, o ve a Unity Gateway y selecciona el servicio.
- Vaya a la pestaña Permisos.
- Haga clic en Permitir.
- Seleccione los usuarios, grupos o entidades de servicio a los que conceder acceso.
- Seleccione el privilegio EXECUTE .
- Haga clic en Permitir.
REST API
databricks api patch \
"/api/2.1/unity-catalog/permissions/model_provider_service/main.default.my_provider" \
--json '{
"changes": [
{ "principal": "data-team", "add": ["EXECUTE"] }
]
}'
CLI
Conceda EXECUTE con la CLI de Databricks. Para instalar la línea de código, consulte Instalar o actualizar la CLI de Databricks.
databricks grants update model_provider_service main.default.my_provider \
--json '{"changes": [{"principal": "data-team", "add": ["EXECUTE"]}]}'
Terraform
Conceda EXECUTE con el proveedor de Databricks Terraform y el recurso databricks_grant:
resource "databricks_grant" "example" {
model_provider_service = "main.default.my_provider"
principal = "data-team"
privileges = ["EXECUTE"]
}
DABs (Beta)
Añade un grants bloque al recurso de servicio del proveedor modelo en tu paquete y vuelve a desplegar para conceder acceso.
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]
SDK de Python
Conceda EXECUTE con el SDK de 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 Desarrollo de Software Go
Conceda EXECUTE con el SDK de 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
Conceda EXECUTE con el SDK de 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 más información sobre concesión y descubrimiento de acceso, consulte Descubrir y gobernar el acceso a proveedores modelo externos (servicios de proveedores modelo).
Configuración de características
Porque un proveedor modelo enruta servicios a través de Unity Gateway, aplica las mismas funciones de gobernanza y observabilidad que usas para otros tráficos de Unity Gateway:
- Registro de inferencias. Registra solicitudes y respuestas a una tabla de Catálogo de Unity. Consulta Solicitudes de registro y respuestas a tablas de inferencia.
- Límites de velocidad. Limite las consultas por minuto para administrar la capacidad y el costo. Consulte Aplicar límites de tasa al modelo y a los servicios MCP.
- Políticas de servicio. Regula el contenido de cada interacción, como bloquear contenido inseguro o redactar datos sensibles, adjuntando una política de servicio. Consulte Directivas de servicio para recursos protegibles de IA y Crear y asociar una directiva de servicio.
Configura un multiplicador de precio
Por defecto, Azure Databricks estima el gasto en modelos externos utilizando los precios de lista publicados por el proveedor. Si el precio de tu proveedor es diferente, configura un multiplicador de precios para reflejar descuentos o márgenes. Por ejemplo, 0.8 utiliza 80% del precio de lista, mientras que 1.2 usa 120%.
- Crea un servicio de proveedor de modelos, o abre un servicio de proveedor de modelos existente en Catalog Explorer o Unity Gateway y haz clic en Editar.
- Expanda Opciones avanzadas.
- Introduce un multiplicador del precio.
- Haz clic en Crear o guardar.
El multiplicador se aplica a todos los modelos disponibles a través del servicio de proveedor de modelos. El gasto calculado en system.ai_gateway.external_model_spend refleja el multiplicador configurado. Los cambios se aplican a las solicitudes realizadas después de que la configuración entre en vigor; las solicitudes anteriores permanecen estimadas usando el precio de lista o el multiplicador configurado previamente.
Un multiplicador configurado muestra una etiqueta de Precio Personalizado . Los precios ajustados tienen un subrayado punteado en las tablas de precios. Coloca el cursor sobre un precio ajustado para comparar el precio ajustado con el precio de lista del proveedor.
Configurar rutas de endpoint para un proveedor personalizado
Las rutas de punto final son opcionales. Úsalos cuando un proveedor personalizado aloja diferentes modelos en diferentes rutas bajo el mismo base_url. Un modelo puede soportar múltiples tipos de API. Cada modelo tiene una ruta de endpoint compartida por sus tipos de API compatibles.
Para configurar una ruta, establece endpoint_route en el destino como una ruta relativa, no una URL completa. Unity Gateway añade la ruta al final de base_url, después de cualquier ruta que base_url ya la contenga .
Interfaz de usuario
- Abre el cuadro de diálogo Crear servicio de proveedor modelo tal como se describe en Crear un servicio proveedor modelo y selecciona Personalizado en la sección Proveedor .
- En la sección Modelos, introduce el nombre de un modelo, selecciona los tipos de API que ese modelo sirve y introduce una ruta relativa en la ruta Endpoint (opcional).
- Haz clic en Añadir modelo. Repita para cada modelo.
- Haga clic en Crear.
REST API
La siguiente solicitud configura rutas separadas para un modelo de chat y un modelo de embeddings:
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" }
}
}
}
}'
Con esta base_url, las solicitudes utilizan las siguientes URL upstream:
-
chat-model:https://api.example.com/gateway/serve/openai/chat -
embedding-model:https://api.example.com/gateway/serve/openai/embed
Si omites endpoint_route o lo estableces como una cadena vacía, Unity Gateway usa base_url sin cambios.
native_api_types selecciona la traducción de la API para cada modelo. No selecciona ni modifica la ruta ascendente.
Actualizar un servicio modelo de proveedor
Debes ser propietario o tener MANAGE. El tipo de proveedor es inmutable.
Interfaz de usuario
Edita la configuración del servicio proveedor de modelos desde la interfaz de Unity Gateway o el Explorador de catálogos. Los cambios se aplican directamente.
REST API
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 (o cualquier otro campo mutable) en el databricks_ai_gateway_model_provider_service recurso y vuelve a aplicar. Los cambios se aplican directamente.
DABs (Beta)
Edita comment (o cualquier otro campo mutable) en el recurso bundle y ejecuta databricks bundle deploy. Los cambios se aplican directamente.
SDK de Python
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 Desarrollo 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'),
});
Eliminación de un servicio de proveedor de modelos
Debes ser propietario o tener MANAGE.
Interfaz de usuario
Abra el servicio del proveedor de modelos en la interfaz de usuario de Unity Gateway o en el Explorador de catálogo y seleccione Eliminar en el menú de tres puntos.
REST API
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
Ejecuta terraform destroy, o elimina el bloque de recursos y vuelve a aplicar.
DABs (Beta)
Elimina el recurso del paquete y corre databricks bundle deploy para eliminarlo.
databricks bundle destroy También funciona, pero elimina todos los recursos que gestiona el paquete, no solo este.
SDK de Python
w.ai_gateway.delete_model_provider_service(
name="model-provider-services/main.default.my_provider"
)
Kit de Desarrollo 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',
});