règles de service pour les objets sécurisables d’IA
Bêta
Cette fonctionnalité est en bêta. Les administrateurs de Workspace peuvent contrôler l'accès à cette fonctionnalité depuis la page Aperçus en optant pour l'aperçu Politiques de service de passerelle Unity . Consultez Gérer les aperçus au niveau du workspace.
Les politiques de service vous permettent de régir le contenu des interactions avec les services d’IA enregistrés dans Unity Catalog, notamment les serveurs MCP externes et les modèles de n’importe quel fournisseur, et pas seulement ceux hébergés par Databricks. Les autorisations Unity Catalog déterminent si un principal peut appeler un service. Les politiques de service régissent la manière dont cette interaction se déroule, en fonction du contenu de la requête et de la réponse, et de la personne effectuant l’appel.
Les politiques de service sont les mécanismes que vous utilisez pour mettre en œuvre des protections pour les services d'IA. Si vous cherchez à ajouter des protections, telles que le blocage des données sensibles, l'injection de prompts ou les contenus non sécurisés, les politiques de service sont le mécanisme : Databricks dispose de protections intégrées pour les risques courants, vous pouvez rédiger des politiques personnalisées pour les règles spécifiques à votre organisation et vous pouvez appliquer les décisions d'un fournisseur de protection tiers avec une politique de service externe.
C'est particulièrement important lorsque les agents agissent pour le compte des utilisateurs. Un agent hérite de tout ce auquel l'utilisateur peut accéder, et les services accèdent souvent à des systèmes externes. Les politiques de service vous permettent de définir des garde-fous pour cette activité. Par exemple, vous pouvez exiger le consentement de l'utilisateur avant qu'un agent ne pousse du code vers un repository Git via un service MCP, refuser la réponse d'un modèle contenant des informations personnelles identifiables (PII) ou bloquer du contenu dangereux.
Les politiques personnalisées peuvent également vérifier et imposer la présence ou l’absence de tags de requête fournis par l’appelant. Consultez Exiger un projet éligible et la référence des tags de requête.
Les politiques de service sont l'un des trois types de politiques de contrôle d'accès basées sur les attributs (ABAC) dans Unity Catalog :
- Les politiques ABAC GRANT accordent des privilèges Unity Catalog sur des éléments sécurisables dont les tags gouvernés correspondent à une condition. Ils déterminent si un principal peut accéder à un objet.
- Row filter and column mask policies contrôlent les lignes et les colonnes qu’un principal peut voir dans une table.
- Les politiques de service régissent le contenu de chaque requête et de chaque réponse adressées à un service IA afin de l’autoriser ou de le rejeter. Sur un service MCP, une politique peut également contenir une demande d’entrée pour approbation.
Les politiques ABAC GRANT relèvent du contrôle d'accès. Les politiques de filtrage de lignes et de masques de colonnes ainsi que les politiques de service sont des politiques de contenu qui régissent ce qui se passe une fois qu'un principal dispose d'un accès. À l'instar d'un filtre de lignes ou d'un masque de colonnes, une politique de service SQL personnalisée fait référence à une fonction Unity Catalog qui contient la logique de gouvernance et l'associe à un élément sécurisable.
Comment les politiques de service complètent les octrois de Unity Catalog
Les privilèges et les politiques de service d'Unity Catalog répondent à différentes questions de gouvernance et opèrent à différents points d'application.
Aspect | Privilèges Unity Catalog | Politiques de service |
|---|---|---|
Question répondue | Ce principal peut-il appeler ce service ? | Comment cette interaction doit-elle procéder ? |
Entrées | Identité du principal et privilèges accordés | Contenu de la demande, contenu de la réponse, balises de demande, annotations d'outils et contexte de l'acteur |
Point d'application | Avant que la requête n'atteigne le service | Avant que le service ne soit invoqué (phase d'entrée, ON CALL) et après que le service a répondu (phase de sortie, ON RESULT) |
Granularité | Par principal, par sécurisable | Par requête, en fonction du contenu et du contexte |
Les stratégies de service ne remplacent pas les autorisations Unity Catalog. Un principal doit d'abord disposer des privilèges Unity Catalog appropriés pour appeler un service. Les stratégies de service évaluent ensuite le contenu de chaque interaction pour appliquer des règles de gouvernance supplémentaires.
Décisions politiques
Une politique de service évalue le contenu d'une requête ou d'une réponse et renvoie l'un des trois résultats suivants :
- **AUTORISER** : l'interaction se poursuit.
- DENY : la politique bloque l’interaction. Pour les APIs de modèle de type chat, au lieu d’un statut d’erreur, Databricks renvoie une réponse réussie (HTTP 200). Sur un service de modèle ou un service de fournisseur de modèle, le tour de l’assistant porte un court message nommant la politique de service qui a bloqué, et un objet
databricks_service_policyde haut niveau porte les détails structurés, y compris le blocreason. Retourner le bloc en tant que tour normal empêche les clients conversationnels qui renvoient l’historique complet, comme les agents de codage, de Trigger à nouveau le même bloc à chaque tour ultérieur. Un refus d’entrée d’intégration renvoie HTTP 400 et bloque l’ensemble de la demande avant que le modèle ne s’exécute. Sur un service MCP, la réponse est une erreur JSON-RPC avec le blocreasondanserror.message. - ASK : sur un service MCP, la règle interrompt une demande pour obtenir l'approbation de l'utilisateur avant que l'outil ne s'exécute. Utilisez cette action lorsqu'un utilisateur doit approuver une opération sensible, telle qu'un appel d'outil MCP destructeur. Pour les agents externes appelant un service MCP, l'invite d'approbation est délivrée par l'élicitation du mode URL MCP. Si une fonction de règle personnalisée renvoie
ASKpour un service de modèle ou un service de fournisseur de modèle, Databricks bloque la demande ou la réponse car ces services ne peuvent pas demander l'approbation de l'utilisateur. Voir Renvoyer une décision.
Une politique personnalisée est soit une fonction définie par l'utilisateur (UDF) SQL qui reçoit l'événement d'interaction (lequel inclut l'acteur et le contenu de la requête ou de la réponse) et renvoie un résultat de décision, soit une politique de type LLM-as-a-judge qui classe le contenu en fonction de critères que vous rédigez en langage naturel. Les politiques intégrées sont gérées par Databricks, et une politique de service externe envoie le contenu à un service de garde tiers qui renvoie la décision.
Points d'évaluation
Databricks évalue les stratégies de service aux points suivants pour les appels d’outils MCP et les requêtes d’API de modèle prises en charge:
- Entrée (ON CALL) : avant que Databricks n'appelle le service, par rapport à la demande. Utilisez cette phase pour inspecter les demandes avant qu'elles n'atteignent le service sous-jacent. Par exemple, bloquez une demande qui appelle un outil MCP destructeur ou refusez une invite contenant des données sensibles avant qu'elle n'atteigne un modèle.
- Sortie (ON RESULT) : après la réponse du service, par rapport à la réponse. Utilisez cette phase pour inspecter les réponses avant qu'elles ne soient renvoyées à l'appelant. Par exemple, bloquez une réponse contenant du contenu hallucinatoire ou des données sensibles.
Les demandes d'embedding ne prennent en charge que la phase d'entrée. Aucune politique n'évalue les vecteurs résultants.
Sur les services de modèle et les services de fournisseur de modèle, les politiques de sortie peuvent vérifier une réponse en streaming au fur et à mesure de sa génération et publier le texte approuvé avant que le modèle ne termine. Voir Streaming responses.
Pour les APIs de modèle de style chat et les appels d'outils MCP, une fonction de politique personnalisée s'exécute aux deux points. Il inspecte la phase actuelle (event:type) et décide de la marche à suivre. Ainsi, une seule politique peut régir la demande, la réponse ou les deux. Pour agir sur une seule phase, créez une branch sur event:type dans le corps de la fonction. Pour les politiques intégrées et les politiques personnalisées LLM-as-a-judge, vous choisissez la phase dans le paramètre Phase du formulaire de politique. Certaines politiques intégrées prennent en charge différentes phases sur différents services. Le garde-fou Jailbreak ne s'exécute que lors de la phase d'entrée sur les services de modèle et de fournisseur de modèles, et sur l'entrée, la sortie ou les deux sur les services MCP. Le formulaire de politique présélectionne la sortie pour Jailbreak sur un service MCP, mais les appelants d’API doivent explicitement définir le champ de demande options.phases de la politique sur pre_call (entrée), post_call (sortie) ou pre_call,post_call (les deux). La détection des hallucinations ne s’exécute que lors de la phase de sortie. Les politiques de service externe sont également délimitées par phase : vous choisissez la phase d’entrée, la phase de sortie ou les deux lorsque vous en ajoutez une.
Ordre d'évaluation
Vous pouvez attacher plus d’une politique de service à un service. Chaque attachement a un rang (priorité), et un DENY à un rang donné arrête l’évaluation aux rangs ultérieurs. Databricks évalue les rangs dans l’ordre croissant lors de la phase d’entrée (ON CALL, rang le plus bas en premier) et dans l’ordre inverse lors de la phase de sortie (ON RESULT). Les politiques au même rang sont évaluées en deux étapes, comme décrit ci-dessous. Utilisez des rangs différents pour contrôler l’ordre d’évaluation.
Évaluation au sein d'un rang
Pour les APIs de modèle de type chat et les appels d'outil MCP, Databricks évalue les politiques au même rang en deux étapes :
- Les politiques LLM-as-a-judge de blocage s’exécutent en parallèle. Il s’agit des politiques LLM-as-a-judge intégrées et personnalisées qui bloquent (
DENY) le contenu, telle que la détection de contenu non sécurisé. Comme il s’agit de vérifications basées sur un modèle, leur exécution simultanée signifie que leur latence ajoutée est approximativement celle de l’évaluation unique la plus lente, et non leur somme. - Les politiques restantes sont ensuite exécutées séquentiellement, mais seulement si aucune politique dans la première étape n’a retourné
DENY. Cette étape couvre les fonctions de politique personnalisées, les politiques de service externes, la politique intégréesystem.ai.detect_sensitive_dataet les politiques qui s’interrompent pour approbation (ASK), notamment un ensemble de politiques LLM-as-a-judge configuré pour demander plutôt que de bloquer. Leur ordre dans cette étape n’est pas défini.ASKmet en pause un appel d’entrée uniquement pour les services MCP. Pour les services de modèle et les services de fournisseur de modèle,ASKbloque la requête ou la réponse.
Un DENY dans l'étape parallèle ignore l'étape séquentielle. L'étape séquentielle ne s'arrête pas à un DENY: chaque stratégie qui s'y trouve est exécutée, même après que l'une d'entre elles renvoie DENY. Par exemple, une stratégie SQL personnalisée qui refuse une requête n'empêche pas une stratégie de service externe au même rang d'envoyer le contenu à son fournisseur. Un DENY dans l'une ou l'autre étape arrête l'évaluation aux rangs ultérieurs ; par conséquent, pour ignorer une stratégie lorsqu'une autre refuse, placez la stratégie de refus à un rang évalué en premier.
Pour les demandes d’intégration, les juges de blocage au même rang s’exécutent un par un, avec jusqu’à quatre éléments d’entrée vérifiés simultanément. Un juge DENY ignore les politiques restantes à ce rang. Voir Barrières de sécurité d’entrée d’intégration pour l’effet sur les appels de juge et la latence.
Le diagramme suivant montre où se situent les deux phases autour d'un service et ce que chaque décision fait :

Pour voir les politiques associées à un service spécifique et leur ordre d'exécution, ouvrez le Policies tab du service et cliquez sur See execution flow .
Réponses en streaming (bêta)
Bêta
L’évaluation de streaming est en Bêta. Cela fait partie de l’aperçu des stratégies de service de passerelle Unity et ne possède pas de bouton bascule distinct. Consultez Gérer les aperçus au niveau du Workspace.
Pour les services de modèle et les services de fournisseur de modèle, chaque politique possède un paramètre Évaluation des réponses qui contrôle la manière dont les politiques de sortie traitent les demandes en streaming :
- Évaluation du streaming : la valeur par default. Les politiques de sortie vérifient la réponse au fur et à mesure que le modèle la génère, et Databricks publie le texte approuvé avant que le modèle ne termine.
- Évaluation complète de la réponse : Les politiques de sortie évaluent la réponse complète avant qu’une partie ne soit publiée.
Les politiques existantes utilisent également une évaluation en streaming par default. Sélectionnez Évaluation de la réponse complète lorsqu'aucun texte ne peut atteindre le client avant que la réponse entière ne soit transmise, ou lorsqu'une politique personnalisée nécessite la réponse complète ou les champs finaux tels que l'utilisation des jetons.
Si une politique de sortie qui s’applique à une requête utilise l’évaluation complète des réponses, y compris une politique en mode Log , chaque politique de sortie évalue la réponse complète. Pour les requêtes de type chat, les politiques SQL et Python personnalisées s’exécutent dans les deux phases ; leur paramètre compte donc aussi. Avec l’évaluation par streaming, ces fonctions s’exécutent sur chaque fenêtre, même si leur logique n’agit que sur la requête. Ce paramètre n’a aucun effet sur les politiques en entrée seule.
L'évaluation en streaming s'applique aux demandes en streaming adressées aux APIs de modèle de type chat prises en charge. Les politiques de sortie utilisent une évaluation complète des réponses pour les demandes de type chat sans streaming et les résultats des outils MCP. Dans l'API, définissez le champ stream_mode d'une politique sur STREAM_MODE_WINDOWED_SYNC pour l'évaluation en streaming ou sur STREAM_MODE_FULLY_BUFFERED pour l'évaluation complète de la réponse. L'omission de ce champ sélectionne l'évaluation en streaming. Les services MCP rejettent ce champ.
Fonctionnement de l'évaluation du streaming
Avec l'évaluation en streaming, Databricks conserve la sortie du modèle et la vérifie dans des fenêtres chevauchantes :
- Avec les paramètres default, Databricks exécute les politiques de sortie après l'arrivée de quelques centaines de nouveaux caractères. Si le Stream est plus lent, le bloc suivant après environ une seconde peut également Trigger une vérification. Une seule vérification s'exécute à la fois par requête.
- Chaque vérification relit le texte de réponse récent, généralement les 16 000 derniers caractères, et tout le texte non publié s'il est plus long. Le chevauchement fournit des politiques de contexte provenant de fenêtres antérieures plutôt que seulement du texte le plus récent.
- Lorsqu'une fenêtre passe, Databricks publie le texte approuvé, conservant généralement une courte fin jusqu'à une vérification ultérieure ou l'achèvement du Stream. Cela réduit le risque de publier une partie d'une valeur sensible avant que la politique ne reconnaisse la valeur complète.
- Une fois terminé, Databricks évalue toute sortie restante ou métadonnée de complétion modifiée, comme l’utilisation de jetons lorsqu’elle est disponible. À partir du premier appel de l’outil client, le reste de la réponse attend l’approbation finale.
- Si une politique refuse la réponse, Databricks retient le texte non publié, ajoute un message indiquant qu'une politique de service a bloqué la réponse et met fin au Stream. Le texte déjà publié reste chez le client.
L'exemple suivant montre des vérifications qui se chevauchent avec une fin retenue.

Le texte atteint le client par rafales plutôt que jeton par jeton, car chaque version attend que les politiques soient terminées. La fin maintenue réduit les risques liés aux limites, mais ne garantit pas que le contenu sensible ne puisse pas atteindre le client.
Politiques de service intégrées
Databricks fournit des politiques de service intégrées sous l'espace de nom system.ai. Celles-ci couvrent les scénarios de gouvernance courants sans SQL personnalisé. Les garde-fous IA de Databricks sont des politiques de service intégrées : des politiques préconfigurées et gérées par Databricks (telles que la détection de contenu non sécurisé et de jailbreak) que vous attachez de la même manière qu’une politique personnalisée :
system.ai.block_unsafe_content: refuse les interactions qui contiennent du contenu dangereux ou nuisible.system.ai.block_jailbreak: détecte le contenu de jailbreak et d'injection de prompt. Sur les services de modèle et les services de fournisseur de modèle, il évalue uniquement l’entrée du modèle. Sur les services MCP, il peut évaluer l’appel d’outil et les arguments en entrée, le résultat de l’outil en sortie ou les deux.system.ai.block_hallucination: refuse les réponses qui contiennent un contenu halluciné.system.ai.detect_sensitive_data: détecte les données sensibles structurées (comme les numéros de carte de crédit et les numéros de sécurité sociale) et soit refuse l’interaction, soit masque les valeurs correspondantes. Contrairement aux autres, il est déterministe (basé sur des modèles, sans modèle d’évaluation) et peut masquer plutôt que simplement refuser. Voir Détecter les données sensibles avec une politique de service.
Pour utiliser une stratégie intégrée, attachez-la à un service. Vous devez disposer de MANAGE sur le service cible.
Les politiques intégrées sont gérées par Databricks et n'apparaissent pas comme des fonctions que vous pouvez parcourir dans le schéma system.ai dans l'explorateur de catalogue. Vous les sélectionnez et les associez par leur nom via l'interface utilisateur Unity Gateway, comme décrit dans Créer et associer une politique de service.
Fonctionnement des stratégies de service intégrées
Les politiques de service intégrées sont de deux types. Chacune des fonctions intégrées LLM-as-a-judge exécute une invite organisée par Databricks par rapport à un modèle d’évaluation pour décider si le contenu enfreint la politique. La détection des données sensibles est déterministe : elle correspond aux modèles et aux sommes de contrôle, et elle n’utilise pas de modèle d’évaluation.
Le service de modèle d'évaluation
Chaque politique de service intégrée exécute son prompt sur un service de modèle d’évaluation , le modèle qui évalue le contenu. Databricks présélectionne un evaluateur par default, de sorte qu’aucun paramétrage n’est requis. Pour utiliser un autre modèle, développez l’élément Options avancées lorsque vous associez la politique et sélectionnez-en un. Vous avez besoin de EXECUTE sur le service de modèle que vous choisissez, ainsi que de USE CATALOG et de USE SCHEMA sur son catalogue et son schéma. Consultez Accorder l’accès à un service de modèle. Databricks vérifie cet accès lorsque vous associez la politique, de sorte que les appelants du service protégé n’ont pas besoin d’accéder à l’évaluateur. L’évaluateur est distinct du service que vous protégez, de sorte qu’une politique peut évaluer une requête adressée à un service de modèle en utilisant un modèle différent comme évaluateur.
Databricks gère le prompt de la politique, qui est en lecture seule. Vous pouvez le consulter sous Prompt lorsque vous associez la politique pour voir les critères exacts que l'évaluateur applique.
Ce que l’évaluateur reçoit
Lorsqu’une politique de service intégré s’exécute, Databricks envoie à l’évaluateur une demande en deux parties :
- Un **message système** qui contient l'invite de stratégie et un contrat de sortie (décrit dans la section suivante).
- Un message utilisateur contenant le contenu à évaluer. Dans la phase d'entrée, il s'agit du dernier message de l'utilisateur sur un modèle ou un service de fournisseur de modèle, ainsi qu'une fenêtre de tours de conversation récents (voir ci-dessous), ou l'appel d'outil et ses arguments sur un service MCP. Dans la phase de sortie, il s'agit de la réponse du modèle ou du résultat de l'outil MCP après l'exécution de l'outil.
L'évaluateur reçoit du texte sérialisé plutôt que des charges utiles image ou audio décodées. Sur la phase de sortie et sur les services MCP, il juge uniquement cet élément extrait. Pour l’évaluation de la sortie Jailbreak sur un service MCP, l’entrée inclut result.content et result.structuredContent, y compris le texte en ligne et les blobs de ressources textuelles. Les autres juges LLM sur les services MCP ne reçoivent que result.content. Dans la phase d’entrée, les juges LLM sur les services MCP ignorent les appels d’outil qui n’ont pas d’arguments.
Le jailbreak sur un service MCP extrait les blobs de ressources de la même manière que la détection des données sensibles. Le décodage est le meilleur effort : les blobs qui ne peuvent pas être décodés ou qui dépassent la limite de taille sont omis. La sélection utilise le type de média (mimeType) déclaré par le serveur MCP. Un type de média manquant ou vide est traité comme du texte, et les blobs déclarés comme non textuels sont exclus. L'évaluateur ne récupère pas les Link de Ressource.
La fonction Jailbreak sur un service MCP filtre les appels d'outils (tools/call) et leurs résultats. Les descriptions d'outils renvoyées par tools/list ne sont pas filtrées.
Pour l’entrée d’incorporation, chaque appel d’évaluateur reçoit un élément non vide.
Lors de la phase d’entrée des APIs de type chat, l’évaluateur reçoit également une fenêtre des tours de conversation récents, afin de pouvoir détecter les schémas qui s’accumulent au fil d’une conversation, comme une escalade progressive. Lorsque vous créez une politique dans le formulaire de politique, la Fenêtre de conversation est définie par default sur les 10 derniers tours. Vous pouvez modifier ce nombre, le définir sur 1 pour ne juger que le dernier message ou sélectionner Évaluer l'intégralité de la conversation . Une politique pour laquelle aucune fenêtre de conversation n'est définie ne juge que le dernier message.
Contrat de sortie
Databricks ajoute automatiquement un contrat de sortie JSON à l'invite de politique, de sorte que l'évaluateur renvoie une décision structurée au lieu d'un texte libre. L'évaluateur renvoie :
flagged(booléen) :truesi le contenu enfreint les critères de la politique.confidence(flottant,0.0à1.0, facultatif) : la confiance de l'évaluateur dans la décision.reason(chaîne) : brève explication des raisons pour lesquelles le contenu a été signalé. Retourné lorsqueflaggedesttrue.
Lorsque l’évaluateur retourne flagged: true, Databricks bloque l’interaction default. Sur un service MCP, une politique configurée pour demander à la place met en pause la requête pour approbation humaine avant l’exécution de l’outil. Parce que Databricks applique le contrat pour vous, les intégrés LLM-as-a-judge ne nécessitent aucune configuration au-delà de la phase et du rang. La détection de données sensibles prend également en compte les balises de classification et une action.
Un évaluateur OpenJev n’utilise pas ce contrat. Il répond plutôt à une question de type indicateur ou autorisation et ne renvoie aucun reason. Consultez Utiliser OpenJev comme évaluateur.
L’évaluateur est un modèle, de sorte que ses verdicts ne sont pas déterministes, et le paramètre reason correspond à un texte libre court plutôt qu’à des données structurées. Pour voir quelles politiques ont été exécutées lors d’une requête et ce que chacune a décidé, utilisez la table de traces unifiée. Pour afficher également le paramètre confidence d'un juge ainsi que le contenu exact qu’il a évalué, activez une table d’inférence sur le service de modèle de l’évaluateur. Consultez la section Déboguer et auditer une décision de politique.
Coût de l'évaluation
Pendant la version bêta, Databricks ne facture pas séparément les politiques de service intégrées. Chaque évaluation est facturée comme tout autre appel au service de modèle d’évaluateur ; le coût dépend donc de la manière dont ce modèle est servi. Les jetons facturés pour chaque évaluation couvrent l’invite de la politique, le contrat de sortie, le message extrait et la réponse de l’évaluateur. Pour limiter les frais généraux, maintenez un petit nombre de politiques par phase et privilégiez un modèle d’évaluateur à faible latence.
Avec l’ évaluation en streaming, un juge de sortie évalue plusieurs fois le texte de réponse qui se chevauche. Chaque évaluation effectue un appel distinct au service de modèle d’évaluation et consomme des jetons d’évaluation. Une réponse en Stream longue peut donc utiliser plus de jetons d’évaluation qu’une évaluation de réponse complète.
Politiques de service externe
Une stratégie de service externe applique les décisions d'un fournisseur de barrières de sécurité tiers, comme un service de sécurité IA ou de prévention des pertes de données. Vous l'attachez avec le type de barrière de sécurité Externe et l'orientez vers une connexion HTTP Unity Catalog qui stocke l'endpoint du fournisseur et les identifiants machine-à-machine OAuth. À chaque évaluation, Databricks envoie le contenu évalué au fournisseur, qui retourne un verdict avec une raison facultative, et Databricks applique le résultat.
Le fournisseur doit implémenter l'API de politique externe Databricks. Les politiques de service externe renvoient ALLOW ou DENY, ou ASK pour maintenir un appel d'outil MCP en attente d'approbation de l'utilisateur. Ils ne peuvent pas supprimer de contenu. Ils échouent par défaut ; un endpoint de fournisseur inaccessible ou lent refuse donc l'appel. Consultez Appliquer une garde-fou de partenaire avec une politique de service externe.
Avec l'évaluation du streaming, une politique de sortie externe appelle le fournisseur pour chaque fenêtre évaluée. Ces appels sont comptabilisés dans les limites de débit et les tarifs du fournisseur.
Services pris en charge
Vous pouvez associer des stratégies de service aux objets sécurisables du service Unity Catalog suivants :
- Services MCP: serveurs MCP gérés, externes et personnalisés.
- Services de modèle: endpoints LLM hébergés et externes.
- **Services de fournisseur de modèles** : fournisseurs de modèles externes gouvernés.
APIs de modèle prises en charge
Sur les services de modèle et les services de fournisseur de modèle, les politiques de service prennent en charge ces APIs de modèle de type chat lors des phases d'entrée et de sortie :
- Complétions de chat : Databricks, OpenAI et Cursor.
- Messages Anthropic.
- Réponses OpenAI et réponses Databricks Open, y compris les requêtes Codex acheminées via ces formats.
- Gemini
generateContentetstreamGenerateContent.
Les politiques de service prennent également en charge l'intégration des entrées dans les requêtes mlflow/v1/embeddings et openai/v1/embeddings. Voir Intégration des gardes-fous d'entrée.
Avec toute politique de service attachée, y compris une politique en mode Log, les requêtes pass-through non gérées renvoient HTTP 400.
Pour les APIs de type chat prises en charge, demandez une réponse unique (n=1 ou candidateCount=1). Les demandes de réponses multiples renvoient HTTP 400 lorsqu’une stratégie est associée, y compris une stratégie en mode Log.
Les politiques de service ne s'exécutent pas sur les requêtes de complétion de texte legacy ou d'inférence System One. Ni la phase d'entrée ni la phase de sortie ne s'exécutent, même lorsqu'une politique est attachée au service. Cette limitation s'applique à tous les types de politiques, y compris la détection de données sensibles, le LLM-as-a-judge, le SQL ou Python personnalisé et les politiques externes. Utilisez une API de modèle prise en charge pour les requêtes qui nécessitent l'application d'une politique.
Une réponse réussie d’une API non prise en charge ne signifie pas qu’une stratégie a évalué la demande ou la réponse.
Intégration de garde-fous d'entrée
Les politiques de service prennent en charge les demandes mlflow/v1/embeddings et openai/v1/embeddings adressées aux services de modèle et aux services de fournisseur de modèle.
Les garde-fous textuels acceptent une chaîne input ou un tableau de chaînes non vide. L’application de garde-fous textuels rejette les tableaux d’ID de jetons, les tableaux mixtes ou imbriqués, les entrées manquantes ou nulles et les tableaux vides. Avec un garde-fou textuel applicatif, un batch peut contenir au maximum 16 éléments. Les batches plus volumineux renvoient une erreur HTTP 400 avant l’exécution du modèle d’embedding. L’API d’intégration et le modèle appliquent toujours leurs limites de texte, de jetons et de taille de requête.
Les politiques de texte suivantes prennent en charge la phase d’entrée (pre_call) :
- Détection des données sensibles, avec refus ou masquage.
- Détection des contenus dangereux et des tentatives de jailbreak, avec refus.
- Politiques personnalisées d’LLM en tant que juge, avec Refuser.
Pour les embeddings, les politiques de service évaluent uniquement l'entrée. Sur un service qui accepte à la fois les demandes de chat et d'embedding, une politique configurée pour les deux phases évalue l'entrée d'embedding et évalue toujours la sortie de chat. Les politiques de sortie uniquement et la détection d'hallucinations ne sont pas prises en charge pour les embeddings. Par exemple, une politique d'hallucination d'application ou une politique de masque de sortie uniquement sur un service de fournisseur de modèle rejette les demandes d'embedding avec HTTP 400 avant l'exécution du modèle. Pour autoriser les demandes d'embedding, choisissez l'une des options suivantes :
- Acheminez les embeddings via un service séparé pour préserver l'application du chat.
- Remplacez la stratégie par une stratégie prenant en charge la phase d’entrée. Si vous ajoutez la phase d’entrée à une stratégie existante, elle start également à vérifier l’entrée du chat.
- Basculez la politique en mode Log. Cela arrête également l’application pour les demandes de chat.
Une politique LLM-as-a-judge évalue séparément chaque élément non vide, indépendamment de sa fenêtre de conversation ou de son paramètre max_turns. Chaque juge effectue un appel par élément non vide ; ainsi, un batch de 16 éléments avec deux juges effectue jusqu’à 32 appels de juge, ce qui augmente la latence et les coûts d’utilisation. Si un juge ne peut pas accepter l’intégralité de l’élément, la demande échoue avec POLICY_EVALUATION_FAILED dans l’erreur reason. Le texte n'est pas tronqué. Si un élément est refusé, la demande entière échoue avec une erreur HTTP 400.
Avec Mask, la détection de données sensibles remplace les correspondances dans chaque élément tout en préservant l'ordre des éléments et les autres champs de requête, tels que model et dimensions. Le modèle intègre le texte expurgé, de sorte que les vecteurs et les résultats de la récupération peuvent changer. La réponse d'intégration n'indique pas si des éléments ont été expurgés ou lesquels.
Pour une récupération cohérente, appliquez la même politique de rédaction au contenu indexé et au texte de query. Si votre application doit savoir si une entrée a changé, rédigez le texte avant d’appeler l’API d’intégrations. Pour juger le texte rédigé, donnez à la politique de rédaction un rang d’entrée inférieur au juge. Le mode Log laisse l’entrée inchangée.
Les politiques SQL et Python personnalisées ne reçoivent que l'événement de demande d'embedding. Les politiques externes reçoivent un événement model_call lorsqu'elles sont configurées pour l'entrée. Aucun des deux types ne reçoit de résultats d'embedding. Une fonction personnalisée qui agit uniquement sur les événements de réponse ne protège pas les demandes d'embedding. Chaque événement d'entrée contient le JSON de la demande complète. Les embeddings ne possèdent pas de message de conversation. Consultez la référence de l’API de la politique des services externes.
Comportement de basculement en mode sécurisé
L’évaluation des politiques de service échoue par défaut pour les appels d’outils MCP et les requêtes d’API de modèles prises en charge. Les requêtes vers les APIs de modèles exclus ignorent l’évaluation de la politique, et ne échouent donc pas par défaut. Lorsque vous attachez une politique via Unity Gateway, Databricks la valide au moment de l'attachement, et toute erreur lors de l'évaluation entraîne DENY. Les erreurs comprennent les erreurs des utilisateurs dans la fonction de politique, les erreurs système, les champs manquants dans le contexte de requête et les délais d’attente. Pour une politique de service externe, les erreurs incluent également un endpoint de fournisseur inaccessible, qui retourne une erreur ou qui retourne un verdict autre que ALLOW, DENY ou ASK.
Une politique mal configurée ou défectueuse bloque l'interaction au lieu de la permettre.
Si une politique de sortie d'application échoue lors de l'évaluation du streaming, le Stream peut se terminer avec une erreur au lieu d'un message de blocage de politique. Les échecs incluent les erreurs d'évaluateur, les délais d'attente et les erreurs de limite de taux. Le client conserve tout texte déjà publié. Si une politique personnalisée nécessite la réponse complète pour s'évaluer avec succès, sélectionnez Évaluation de la réponse complète .
Une politique en mode Logs n’est pas appliquée. Il enregistre ce que la politique aurait décidé sans bloquer l'interaction, de sorte que même un DENY potentiel laisse la requête se poursuivre. La validation des requêtes s'applique toujours, y compris la validation des tags de requête.
Limitations
Les limitations suivantes s’appliquent :
- Stratégies d’embedding : les stratégies de service prennent en charge uniquement la phase d’entrée pour les embeddings. Consultez Garde-fous d’entrée des embeddings.
- Couverture de l’API de modèle : la couverture dépend de l’API de modèle. Voir APIs de modèles prises en charge.
- Transformation : les politiques de service renvoient une décision (ALLOW, DENY ou ASK) et ne transforment pas le contenu de la requête ou de la réponse. La seule exception est la politique intégrée
system.ai.detect_sensitive_data, qui peut masquer les valeurs correspondantes sur les services de modèle. - Stratégies de service externe : une stratégie de service externe retourne
ALLOWouDENY, ouASKlors d'un appel d'outil MCP, et prend en charge uniquement l'authentification machine-à-machine OAuth. Voir Limitations des politiques de service externe. - Services pris en charge : Les politiques de service s'appliquent aux services MCP, aux services de modèle et aux services de fournisseur de modèle. Les Services aux agents ne sont pas pris en charge.
- Passthrough de service de fournisseur de modèle : Sur un service de fournisseur de modèle, Databricks rejette les demandes de passthrough non gérées avec HTTP 400 lorsqu'une politique est jointe, y compris une politique en mode Log. Sans politique jointe, Transférer tous les chemins d'URL transfère ces demandes au fournisseur. Les politiques évaluent uniquement les chemins API pris en charge par le fournisseur.
- Fenêtre de conversation : les évaluateurs LLM intégrés et personnalisés peuvent utiliser une fenêtre de conversation uniquement lors de l’évaluation des entrées sur les services de modèle et de fournisseur de modèle. Pour ces évaluateurs, l’évaluation des sorties et les services MCP utilisent un message, un appel d’outil ou un résultat d’outil. Pour les APIs de modèles de type chat, les fonctions SQL et Python personnalisées reçoivent un objet neutre vis-à-vis du fournisseur sous
event:context.conversationlors de l’évaluation des entrées comme des sorties. Lors de l’évaluation des sorties, l’objet contient la conversation de la requête d’origine. Consultez Fonctionnement des stratégies de service intégrées et Contexte de conversation. Les évaluateurs d’embeddings évaluent chaque élément non vide indépendamment, et les événements d’embedding ne disposent d’aucun contexte conversationnel. - Réponses en streaming : Le texte publié ne peut pas être rappelé après un refus ou une erreur d’évaluation. Chaque vérification, y compris la vérification finale, utilise un retour en arrière limité, de sorte qu’une longue réponse pourrait ne jamais être entièrement évaluée par une seule vérification. Voir How streaming evaluation works.
- Évaluation imbriquée : Si le service de modèle d'évaluateur que vous sélectionnez pour une politique de service intégré possède ses propres politiques attachées, Databricks les ignore lors de l'exécution de l'évaluation. Cela empêche la récursion.
Étapes suivantes
- Créer et associer une politique de service
- Exemples de politiques de service
- Détectez les données sensibles avec une politique de service
- Appliquez un garde-fou de partenaire avec une politique de service externe
- Référence de la fonction de politique de service
- Tutoriel : ajouter des garde-fous de politique de service à un service de modèle