Services de modèle personnalisés
Un service de modèle est un endpoint qui traduit et achemine les requêtes d'inférence vers un ou plusieurs modèles, avec une répartition du trafic et des fallbacks. Il prend en charge les requêtes en temps réel, ainsi que l'inférence par batch.
Créer un service de modèle personnalisé pour des cas d’utilisation tels que les suivants :
- Un endpoint indépendant du modèle pour une application. Attribuez un service nommé
production.ai.support-assistantà un assistant de support client. Modifiez le modèle sous-jacent sans changer le nom appelé par l'application. - Routage personnalisé et fallbacks. Utilisez la répartition du trafic pour envoyer 10 % du trafic vers un nouveau modèle avant un déploiement plus large, ou configurez une destination de secours pour les requêtes ayant échoué.
- Un budget pour une charge de travail. Marquez un service avec
project=support-assistantet délimitez un budget mensuel à ce tag, avec une alerte à partir de 1 000 $ de dépenses. - Contrôles d’accès pour une équipe. Accordez à l’équipe juridique et à ses Service Principals d’application l’accès à un service
legal-reviewet utilisez des services distincts pour les autres équipes. - Limites de débit pour une charge de travail. Configurez un service de test pour 100 requêtes par minute et un service de production pour 1 000 requêtes par minute à l’aide des limites de débit du service.
- Séparer le monitoring et les logs. Envoyez les requêtes et les réponses d'un assistant de support vers une table d'inférence dédiée afin de pouvoir inspecter son trafic séparément de celui de l'agent de codage.
Pour query un modèle de fondation servi par Databricks sans créer de service, utilisez un service de modèle fourni par le système dans system.ai.
Un service peut acheminer des requêtes vers des modèles hébergés par Databricks, en utilisant le paiement au jeton ou le throughput provisionné, ou vers des modèles externes par l'intermédiaire d'un fournisseur de modèle. Vous pouvez combiner ces destinations dans un même service.
Les services de modèle personnalisés sont des éléments sécurisables d'Unity Catalog. Les appelants les invoquent par leur nom complet, catalog.schema.name, à travers les workspaces ou depuis l'extérieur de Databricks. Voir Gouvernance et privilèges.
Exigences
- Un workspace Databricks dans une région prise en charge par Unity Gateway.
- Unity Catalog activé pour votre workspace. Consultez Activer un workspace pour Unity Catalog.
- Pour créer un service de modèle, vous devez disposer des éléments suivants :
USE CATALOG,USE SCHEMAetCREATE SERVICEsur le catalogue et le schéma où vous créez le service de modèle.EXECUTEsur chaque modèle que le service de modèle référence comme destination.EXECUTE,USE CATALOGetUSE SCHEMAsur chaque fournisseur de modèles que le service de modèle référence comme destination.USE CATALOG,USE SCHEMAetCREATE TABLEsur le catalogue et le schéma où la table d’inférence est créée, si vous activez la journalisation de l’inférence.
Créer un service de modèle personnalisé
Créer un service de modèle dans l’interface utilisateur de Unity Gateway ou dans l’Explorateur de catalogues. Pour en créer un par programmation, utilisez l’API REST, les SDK Databricks, la CLI Databricks, Terraform ou les automatisations déclaratives (DAB).
Les services de modèle et les fournisseurs de modèles partagent un espace de noms unique dans un schéma Unity Catalog. Vous ne pouvez pas utiliser un nom pour un service de modèle si un fournisseur de modèle dans le schéma l’utilise déjà, et vice versa.
- UI
- REST API
- CLI
- Terraform
- DABs (Beta)
- Python SDK
- Go SDK
- Go Modular SDK
- Java SDK
- JS Modular SDK
-
Effectuez l’une des actions suivantes :
- Dans la barre latérale du workspace, cliquez sur AI Gateway , puis cliquez sur Créer .
- Dans l'Explorateur de catalogues, accédez au schéma dans lequel vous souhaitez créer le service de modèle, puis cliquez sur Créer > Service > Service de modèle .
-
Saisissez un nom pour le service de modèle, puis sélectionnez le catalogue et le schéma dans lesquels le créer. Si vous start à partir de l’Explorateur de catalogue, celui-ci préremplit le catalogue et le schéma.
-
Sélectionnez la destination principale à desservir. Cette destination peut être un modèle servi par Databricks sur lequel vous avez
EXECUTEet que Unity Gateway peut servir, ou un fournisseur de modèles sur lequel vous avezEXECUTE,USE CATALOGetUSE SCHEMA. -
Cliquez sur Créer .
Une fois le service de modèle créé, Databricks ouvre sa page de présentation, où vous pouvez commencer ou configurer des fonctionnalités supplémentaires telles que la journalisation des inférences.
Envoyer un POST à /api/2.1/unity-catalog/model-services, en transmettant parent et model_service_id en tant que paramètres de query. La configuration de routage doit comporter au moins une 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
}
]
}
}
}'
Transmettez le schéma parent et un nom feuille, et fournissez la configuration avec --json. La configuration de routage doit comporter au moins une destination. Pour installer la CLI, consultez Installer ou mettre à jour la CLI 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
}
]
}
}
}'
Créez et gérez un service de modèle avec le fournisseur Databricks Terraform et la ressource 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
}]
}
}
}
Définissez le service de modèle dans un bundle et déployez-le avec databricks bundle deploy. La configuration de routage doit comporter au moins une 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
Créer et gérer un service de modèle avec le SDK Python Databricks:
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,
)
]
)
),
),
)
Créez et gérez un service de modèle avec le Databricks SDK for 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,
}},
},
},
},
})
Créez et gérez un service de modèle avec le kit SDK Databricks AI Gateway pour Go. Les champs facultatifs sont des pointeurs. L'exemple utilise donc une fonction d'assistance sur une seule ligne, 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"),
},
},
}},
},
},
},
})
Créez et gérez un service de modèle avec le SDK Databricks pour 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)));
Créez et gérez un service de modèle avec le SDK Databricks AI Gateway pour 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,
},
],
},
},
},
});
Accorder l’accès à un service de modèle
Par default, seul le propriétaire du service de modèle peut l'interroger. Pour permettre à d'autres utilisateurs d'interroger un service de modèle, accordez-leur EXECUTE sur celui-ci, ainsi que USE CATALOG et USE SCHEMA sur son catalogue et son schéma. Si le service de modèle écrit des logs dans une table d'inférence, accordez SELECT sur la table pour leur permettre de lire les requêtes et les réponses consignées.
- UI
- REST API
- CLI
- Terraform
- DABs (Beta)
- Python SDK
- Go SDK
- Java SDK
- Ouvrez le service de modèle dans Catalog Explorer, ou accédez à AI Gateway et sélectionnez le service.
- Accédez à l’onglet tab .
- Cliquez sur Grant .
- Sélectionnez les utilisateurs, les groupes ou les Service Principals auxquels accorder l’accès.
- Select the EXECUTE privilege.
- Cliquez sur Grant .
databricks api patch \
"/api/2.1/unity-catalog/permissions/model_service/main.default.my_model_service" \
--json '{
"changes": [
{ "principal": "data-team", "add": ["EXECUTE"] }
]
}'
Accordez EXECUTE avec la CLI Databricks. Pour installer la CLI, consultez Installer ou mettre à jour la CLI Databricks.
databricks grants update model_service main.default.my_model_service \
--json '{"changes": [{"principal": "data-team", "add": ["EXECUTE"]}]}'
Accordez EXECUTE avec le fournisseur Databricks Terraform et la ressource databricks_grant :
resource "databricks_grant" "example" {
model_service = "main.default.my_model_service"
principal = "data-team"
privileges = ["EXECUTE"]
}
Ajoutez un bloc grants à la ressource de service de modèle de votre bundle et redéployez pour accorder l’accès.
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]
Accordez EXECUTE avec le SDK Databricks pour 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])],
)
Accordez EXECUTE avec le 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},
}},
})
Accordez EXECUTE avec le Databricks SDK for 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)))));
Consultez Découvrir et gouverner l'accès aux services de modèle pour en savoir plus sur l'octroi et la découverte des accès.
Configurer les fonctionnalités sur un service de modèle
Configurez les limites de débit, la journalisation des inférences et les garde-fous implémentés avec les politiques de service sur le service de modèle à partir de l’interface utilisateur Unity Gateway. Voir :
- Appliquer des limites de débit aux services de modèle et MCP
- Logs les requêtes et les réponses dans des tables d’inférence
Journalisation des inférences
Lorsque vous activez la journalisation des inférences, Databricks crée une nouvelle table Unity Catalog vide dotée d'un schéma prédéfini à l'emplacement que vous spécifiez. Notez les éléments suivants :
- Vous devez disposer de
USE CATALOG, deUSE SCHEMAet deCREATE TABLEsur le catalogue et le schéma cibles. - Le créateur du service de modèle est le propriétaire de la table d’inférence. Aucun autre utilisateur n'a accès, sauf si vous le lui accordez.
- Si une table existe déjà à l’emplacement spécifié, la création du service de modèle échoue.
- La table d'inférence possède un cycle de vie indépendant du service de modèle. Si vous supprimez la table, le service de modèle continue de fonctionner mais arrête la journalisation.
Pour en savoir plus sur les tables d’inférence, consultez Logs les requêtes et les réponses dans des tables d’inférence.
Mettre à jour un service de modèle
Vous devez être propriétaire ou disposer de MANAGE.
- UI
- REST API
- CLI
- Terraform
- DABs (Beta)
- Python SDK
- Go SDK
- Go Modular SDK
- Java SDK
- JS Modular SDK
Edit the model service's configuration from the Unity Gateway UI or Catalog Explorer. Les modifications s'appliquent sur place.
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"}'
Modifiez comment (ou tout autre champ mutable) sur la ressource databricks_ai_gateway_model_service et réappliquez. Les modifications s’appliquent sur place.
Modifiez comment (ou tout autre champ mutable) dans la ressource du bundle et exécutez databricks bundle deploy. Les modifications s'appliquent sur place.
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'),
});
Supprimer un service de modèle
Vous devez être propriétaire ou disposer de MANAGE. Les services de modèles fournis par le système dans system.ai ne peuvent pas être supprimés.
- UI
- REST API
- CLI
- Terraform
- DABs (Beta)
- Python SDK
- Go SDK
- Go Modular SDK
- Java SDK
- JS Modular SDK
Ouvrez le service de modèle dans l’interface utilisateur de Unity Gateway ou l’Explorateur de catalogues, puis sélectionnez Delete dans le menu kebab.
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
Exécutez terraform destroy, ou supprimez le bloc de ressources et réappliquez.
Supprimez la ressource du bundle et exécutez databricks bundle deploy pour la supprimer. databricks bundle destroy fonctionne également, mais il supprime toutes les ressources gérées par le bundle, et pas seulement celle-ci.
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' });
Gouvernance et privilèges
As a Unity Catalog securable object, a model service:
- **Vit dans un catalogue et un schéma**, où il hérite des paramètres du schéma tels que les liaisons de workspace.
- Contient les métadonnées standard de Unity Catalog , telles que le nom, le propriétaire, le commentaire et les tags.
- Est régi par les privilèges Unity Catalog , vous accordez donc l'accès en utilisant les mêmes déclarations
GRANTetREVOKEque vous utilisez pour les tables, les fonctions et les modèles. - **Est découvrable dans Catalog Explorer**, aux côtés du reste de vos assets Unity Catalog.
Les privilèges suivants s'appliquent :
Privilège | Description |
|---|---|
| Accéder au catalogue et au schéma qui contiennent le service de modèle. Requis pour toutes les Opérations. |
| Créez des services de modèle dans un schéma. Accordé sur le catalogue ou le schéma. |
| Interroger un service de modèle. |
| Modifier ou supprimer un service de modèle et gérer ses autorisations. Le propriétaire a un sur-ensemble de |
Les services de modèles utilisent les privilèges du propriétaire. Databricks évalue une query en fonction des privilèges de l' owner plutôt que de ceux de l'appelant. Lorsqu'un utilisateur interroge un service de modèle, Databricks vérifie que le propriétaire dispose de EXECUTE sur les destinations référencées, telles que les modèles sous-jacents et les fournisseurs de modèles. L'appelant n'a pas besoin d'un accès direct à ces destinations.
Limitations
Les capacités suivantes ne sont pas prises en charge :
- Création et gestion de services de modèle avec SQL.
- Découverte des services de modèle avec seulement le privilège
BROWSE. - Recherche globale de services de modèle.