Authentification pour les agents d'IA (Model Serving)

info

Pour les nouveaux cas d'utilisation, Databricks recommande de déployer des agents sur Databricks Apps pour un contrôle total sur le code des agents, la configuration du serveur et le workflow de déploiement. Consultez Créer un agent IA et le déployer sur Databricks Apps. Pour migrer un agent existant, consultez Migrer un agent de Model Serving vers Databricks Apps.

Les agents IA doivent souvent s'authentifier auprès d'autres ressources pour accomplir des tâches. Par exemple, un agent déployé pourrait avoir besoin d'accéder à un index AI Search pour query des données non structurées ou au Prompt Registry pour charger des prompts dynamiques.

Cette page couvre les méthodes d'authentification disponibles lors du développement et du déploiement d'agents utilisant des agents personnalisés.

Méthodes d'authentification

Le tableau suivant compare les méthodes d’authentification disponibles. Vous pouvez combiner ces approches :

Méthode	Description	Posture de sécurité	Complexité de la configuration
Transmission automatique des informations d'authentification	L'agent s'exécute avec les autorisations de l'utilisateur qui l'a déployé. Databricks gère automatiquement les identifiants de courte durée pour les ressources déclarées.	Identifiants à courte durée de vie, rotation automatique	Faible - déclarez les dépendances au moment de la journalisation
Authentification utilisateur « Au nom de » (OBO)	L'agent s'exécute avec les autorisations de l'utilisateur final qui effectue la requête.	Utilise les informations d'identification de l'utilisateur final avec des périmètres restreints.	Moyen - nécessite la déclaration de la portée et l'initialisation du runtime
Authentification manuelle	Fournir explicitement les identifiants à l'aide de variables d'environnement	Les identifiants à long terme nécessitent une gestion de la rotation.	Élevé - nécessite une gestion manuelle des identifiants.

Méthode	Description	Posture de sécurité	Complexité de la configuration
Transmission automatique des informations d'authentification	L'agent s'exécute avec les autorisations de l'utilisateur qui l'a déployé. Databricks gère automatiquement les identifiants de courte durée pour les ressources déclarées.	Identifiants à courte durée de vie, rotation automatique	Faible - déclarez les dépendances au moment de la journalisation
Authentification utilisateur « Au nom de » (OBO)	L'agent s'exécute avec les autorisations de l'utilisateur final qui effectue la requête.	Utilise les informations d'identification de l'utilisateur final avec des périmètres restreints.	Moyen - nécessite la déclaration de la portée et l'initialisation du runtime
Authentification manuelle	Fournir explicitement les identifiants à l'aide de variables d'environnement	Les identifiants à long terme nécessitent une gestion de la rotation.	Élevé - nécessite une gestion manuelle des identifiants.

Choisissez la bonne méthode d'authentification pour votre ressource

Utilisez ce diagramme pour choisir la bonne méthode d'authentification pour chaque ressource. Vous pouvez combiner les méthodes selon vos besoins, et un agent peut utiliser une méthode différente pour chaque ressource en fonction de son cas d'utilisation.

1. Un contrôle d'accès par utilisateur ou un audit attribué à l'utilisateur est-il requis ?

   • Oui → Utiliser l'authentification utilisateur « Au nom de »
   • Non → Passez à l'étape 2

2. Toutes les Ressources prennent-elles en charge l'authentification automatique?

   • Oui → Utilisez la transmission automatique d'authentification (recommandée)
   • Non → Utilisez l'authentification manuelle

Authentifiez-vous auprès des serveurs MCP Databricks

Pour vous authentifier auprès des serveurs MCP Databricks, spécifiez toutes les ressources dont votre agent a besoin au moment de la connexion.

Par exemple, si votre agent utilise les URL des serveurs MCP listées ci-dessous, vous devez spécifier tous les index AI Search dans les schémas prod.customer_support et prod.billing. Vous devez également spécifier toutes les fonctions Unity Catalog dans prod.billing:

• https://<your-workspace-hostname>/api/2.0/mcp/ai-search/prod/customer_support
• https://<your-workspace-hostname>/api/2.0/mcp/ai-search/prod/billing
• https://<your-workspace-hostname>/api/2.0/mcp/functions/prod/billing

Pour simplifier le processus d'identification de toutes les ressources dépendantes pour les serveurs MCP gérés, utilisez le package PyPI databricks-mcp databricks_mcp.DatabricksMCPClient().get_databricks_resources(<server_url>) pour récupérer les ressources nécessaires au serveur MCP géré.

Si votre agent interroge un serveur MCP personnalisé hébergé sur une application Databricks, vous pouvez configurer l'autorisation en incluant explicitement le serveur en tant que ressource lors de l'enregistrement de votre modèle.

Transmission automatique de l'authentification

L'authentification par transmission automatique est le moyen le plus simple d'accéder aux ressources gérées par Databricks. Déclarez les dépendances des ressources lors de l'enregistrement de l'agent, et Databricks provisionne, renouvelle et gère automatiquement les informations d'identification de courte durée lorsque l'agent est déployé.

Ce comportement d'authentification est similaire au comportement « Exécuter en tant que propriétaire » pour les tableaux de bord Databricks. Les ressources en aval, telles que les tables Unity Catalog, sont accessibles à l'aide des identifiants d'un Service Principal avec un accès à privilèges minimum uniquement aux ressources dont l'agent a besoin.

Comment fonctionne la transmission automatique de l’authentification

Lorsqu'un agent est servi derrière un endpoint utilisant la transmission automatique d'authentification, Databricks effectue les étapes suivantes :

1. Vérification des autorisations : Databricks vérifie que le créateur de l'endpoint peut accéder à toutes les dépendances spécifiées lors de l'enregistrement de l'agent.

2. **Création et octrois de Service Principal** : Un Service Principal est créé pour la version du modèle d'agent et se voit automatiquement accorder un accès en lecture aux ressources de l'agent.

remarque

Le Service Principal généré par le système n'apparaît pas dans les listes de l'API ou de l'interface utilisateur. Si la version du modèle d'agent est supprimée de l'endpoint, le Service Principal est également supprimé.

3. Provisionnement et rotation des identifiants : des identifiants de courte durée (un jeton M2M OAuth) pour le Service Principal sont injectés dans l'Endpoint, permettant au code de l'agent d'accéder aux ressources Databricks. Databricks fait également pivoter les identifiants, garantissant que votre agent dispose d'un accès continu et sécurisé aux ressources dépendantes.

Ressources prises en charge pour la transmission automatique des identifiants d'authentification

Le tableau suivant répertorie les ressources Databricks qui prennent en charge la transmission automatique de l'authentification et les autorisations que le créateur du Endpoint doit avoir lors du déploiement de l'agent.

remarque

Les ressources Unity Catalog nécessitent également USE SCHEMA sur le schéma parent et USE CATALOG sur le catalogue parent.

Type de ressource	Autorisation	Version minimale de MLflow
SQL Warehouse	Use Endpoint	2,16.1 ou supérieur
Endpoint de Model Serving	Can Query	2.13.1 ou supérieur
Fonction Unity Catalog	EXECUTE	2,16.1 ou supérieur
Genie Agent	Can Run	2.17,1 ou version ultérieure
Index de recherche IA	Can Use	2.13.1 ou supérieur
Table Unity Catalog	SELECT	2.18.0 ou au-dessus
Connexion Unity Catalog	Use Connection	2.17,1 ou version ultérieure
Lakebase	databricks_superuser	3.3.2 ou plus

Type de ressource	Autorisation	Version minimale de MLflow
SQL Warehouse	Use Endpoint	2,16.1 ou supérieur
Endpoint de Model Serving	Can Query	2.13.1 ou supérieur
Fonction Unity Catalog	EXECUTE	2,16.1 ou supérieur
Genie Agent	Can Run	2.17,1 ou version ultérieure
Index de recherche IA	Can Use	2.13.1 ou supérieur
Table Unity Catalog	SELECT	2.18.0 ou au-dessus
Connexion Unity Catalog	Use Connection	2.17,1 ou version ultérieure
Lakebase	databricks_superuser	3.3.2 ou plus

Implémenter la transmission automatique de l'authentification

Pour activer la transmission automatique de l'authentification, spécifiez les Ressources dépendantes lorsque vous enregistrez l'agent. Utilisez le parameter resources de l'API log_model() :

remarque

N'oubliez pas d'enregistrer également toutes les ressources dépendantes en aval. Par exemple, si vous Log un Genie Agent, vous devez également Log ses tables, ses SQL Warehouse et ses fonctions Unity Catalog.

Python

import mlflow
from mlflow.models.resources import (
  DatabricksVectorSearchIndex,
  DatabricksServingEndpoint,
  DatabricksSQLWarehouse,
  DatabricksFunction,
  DatabricksGenieSpace,
  DatabricksTable,
  DatabricksUCConnection,
  DatabricksApp,
  DatabricksLakebase
)

with mlflow.start_run():
  logged_agent_info = mlflow.pyfunc.log_model(
    python_model="agent.py",
    artifact_path="agent",
    input_example=input_example,
    example_no_conversion=True,
    # Specify resources for automatic authentication passthrough
    resources=[
      DatabricksVectorSearchIndex(index_name="prod.agents.databricks_docs_index"),
      DatabricksServingEndpoint(endpoint_name="databricks-meta-llama-3-3-70b-instruct"),
      DatabricksServingEndpoint(endpoint_name="databricks-bge-large-en"),
      DatabricksSQLWarehouse(warehouse_id="your_warehouse_id"),
      DatabricksFunction(function_name="ml.tools.python_exec"),
      DatabricksGenieSpace(genie_space_id="your_genie_space_id"),
      DatabricksTable(table_name="your_table_name"),
      DatabricksUCConnection(connection_name="your_connection_name"),
      DatabricksApp(app_name="app_name"),
      DatabricksLakebase(database_instance_name="lakebase_instance_name"),
    ]
  )

Authentification « au nom de l'utilisateur »

info

Aperçu

Cette fonctionnalité est en Aperçu public.

L'authentification « Au nom de » (OBO) permet à un agent d'agir en tant qu'utilisateur Databricks qui exécute la query. Ceci fournit :

• Accès par utilisateur aux données sensibles.
• Contrôles de données granulaires appliqués par Unity Catalog
• Les jetons de sécurité sont restreints (« à portée réduite ») aux seules APIs que votre agent déclare, afin de réduire les risques de mauvaise utilisation.

Exigences

• L'authentification de l'utilisateur en son nom nécessite MLflow 2,22.1 et supérieur.
• L'authentification au nom de l'utilisateur est désactivée par default et doit être activée par un administrateur de Workspace. Examinez les considérations de sécurité avant d'activer cette fonctionnalité.

Ressources prises en charge par OBO

Sur les endpoints de Model Serving, les agents avec l'authentification OBO ne peuvent accéder qu'aux ressources Databricks répertoriées dans le tableau suivant. Les Ressources non répertoriées ici, telles que les volumes Unity Catalog (upload/download de fichiers), ne sont pas prises en charge pour OBO sur Model Serving.

remarque

Si votre agent nécessite un accès OBO à un ensemble plus large de ressources, Databricks vous recommande de déployer votre agent sur Databricks Apps, qui prend en charge des étendues OAuth supplémentaires. Consultez Migrer un agent de Model Serving vers Databricks Apps.

Ressource Databricks	Clients compatibles
Index de recherche IA	databricks_langchain.VectorSearchRetrieverTool, databricks_openai.VectorSearchRetrieverTool, VectorSearchClient
Endpoint de Model Serving	databricks.sdk.WorkspaceClient
SQL Warehouse	databricks.sdk.WorkspaceClient
Connexions UC	databricks.sdk.WorkspaceClient
Tables et fonctions UC	databricks.sdk.WorkspaceClient (Pour accéder aux tables UC, vous devez utiliser des queries SQL via l'API d'exécution d'instructions SQL)
Genie Agent	databricks.sdk.WorkspaceClient (recommandé), databricks_langchain.GenieAgent, ou databricks_ai_bridge.GenieAgent
Protocole de contexte du modèle (MCP)	databricks_mcp.DatabricksMCPClient

Ressource Databricks	Clients compatibles
Index de recherche IA	databricks_langchain.VectorSearchRetrieverTool, databricks_openai.VectorSearchRetrieverTool, VectorSearchClient
Endpoint de Model Serving	databricks.sdk.WorkspaceClient
SQL Warehouse	databricks.sdk.WorkspaceClient
Connexions UC	databricks.sdk.WorkspaceClient
Tables et fonctions UC	databricks.sdk.WorkspaceClient (Pour accéder aux tables UC, vous devez utiliser des queries SQL via l'API d'exécution d'instructions SQL)
Genie Agent	databricks.sdk.WorkspaceClient (recommandé), databricks_langchain.GenieAgent, ou databricks_ai_bridge.GenieAgent
Protocole de contexte du modèle (MCP)	databricks_mcp.DatabricksMCPClient

Implémenter l'authentification OBO

Pour activer l'authentification au nom de l'utilisateur, suivez les étapes suivantes :

1. Mettez à jour les appels SDK afin de spécifier que les ressources sont consultées au nom de l'utilisateur final.
2. Mettez à jour le code de l'agent pour initialiser l'accès OBO dans la fonction predict, et non dans __init__, car l'identité de l'utilisateur n'est connue qu'au moment de l'exécution.
3. Lors de l'enregistrement de l'agent pour le déploiement, déclarez les périmètres de l'API REST de Databricks dont l'agent a besoin.

Les extraits suivants expliquent comment configurer l'accès au nom de l'utilisateur aux différentes ressources Databricks. Lors de l'initialisation des outils, gérez les erreurs d'autorisation avec élégance en encapsulant l'initialisation dans un bloc try-except.

AI Search Retriever Tool

Python

from databricks.sdk import WorkspaceClient
from databricks_ai_bridge import ModelServingUserCredentials
from databricks_langchain import VectorSearchRetrieverTool

# Configure a Databricks SDK WorkspaceClient to use on behalf of end
# user authentication
user_client = WorkspaceClient(credentials_strategy = ModelServingUserCredentials())

vector_search_tools = []
# Exclude exception handling if the agent should fail
# when users lack access to all required Databricks resources
try:
  tool = VectorSearchRetrieverTool(
    index_name="<index_name>",
    description="...",
    tool_name="...",
    workspace_client=user_client # Specify the user authorized client
    )
    vector_search_tools.append(tool)
except Exception as e:
    _logger.debug("Skipping adding tool as user does not have permissions")

AI Search Client

Python

from databricks.vector_search.client import VectorSearchClient
from databricks.vector_search.utils import CredentialStrategy

# Configure a VectorSearch Client to use on behalf of end
# user authentication
user_authenticated_vsc = VectorSearchClient(credential_strategy=CredentialStrategy.MODEL_SERVING_USER_CREDENTIALS)
# Exclude exception handling if the agent should fail when
# users lack access to all required Databricks resources
try:
  vs_index = user_authenticated_vsc.get_index(endpoint_name="endpoint_name", index_name="index_name")
  ...
except Exception as e:
  _logger.debug("Skipping Vector Index because user does not have permissions")

MCP

Python

from databricks.sdk import WorkspaceClient
from databricks_ai_bridge import ModelServingUserCredentials
from databricks_mcp import DatabricksMCPClient

# Configure a Databricks SDK WorkspaceClient to use on behalf of end
# user authentication
user_client = WorkspaceClient(credentials_strategy=ModelServingUserCredentials())

mcp_client = DatabricksMCPClient(
    server_url="<mcp_server_url>",
    workspace_client=user_client, # Specify the user client here
  )

Model Serving Endpoint

Python

from databricks.sdk import WorkspaceClient
from databricks_ai_bridge import ModelServingUserCredentials

# Configure a Databricks SDK WorkspaceClient to use on behalf of end
# user authentication
user_client = WorkspaceClient(credentials_strategy=ModelServingUserCredentials())

# Exclude exception handling if the agent should fail
# when users lack access to all required Databricks resources
try:
  user_client.serving_endpoints.query("endpoint_name", input="")
except Exception as e:
  _logger.debug("Skipping Model Serving Endpoint due to no permissions")

UC Connections

Python

import requests
from databricks.sdk import WorkspaceClient
from databricks_ai_bridge import ModelServingUserCredentials

# Configure a Databricks SDK WorkspaceClient to use on behalf of end
# user authentication
user_client = WorkspaceClient(credentials_strategy=ModelServingUserCredentials())

response = requests.post(
  f"{user_client.config.host}/api/2.0/unity-catalog/connections/connection_name/proxy/api/v1/resource",
  headers={
    **user_client.config.authenticate(),
    "Content-Type": "application/json",
  },
  json={"key": "value"},
)

Genie Agents (WorkspaceClient)

Python

from databricks_langchain.genie import GenieAgent
from databricks.sdk import WorkspaceClient
from databricks_ai_bridge import ModelServingUserCredentials


# Configure a Databricks SDK WorkspaceClient to use on behalf of end
# user authentication
user_client = WorkspaceClient(credentials_strategy=ModelServingUserCredentials())


genie_agent = GenieAgent(
    genie_space_id="space-id",
    genie_agent_name="Genie",
    description="This Genie Agent has access to sales data in Europe",
    client=user_client
)

# Use the Genie SDK methods available through WorkspaceClient
try:
    response = agent.invoke("Your query here")
except Exception as e:
    _logger.debug("Skipping Genie due to no permissions")

Genie Agents (LangChain)

Python

from databricks.sdk import WorkspaceClient
from databricks_ai_bridge import ModelServingUserCredentials
from databricks_langchain.genie import GenieAgent

# Configure a Databricks SDK WorkspaceClient to use on behalf of end
# user authentication
user_client = WorkspaceClient(credentials_strategy=ModelServingUserCredentials())

genie_agent = GenieAgent(
    genie_space_id="<genie_space_id>",
    genie_agent_name="Genie",
    description="Genie_description",
    client=user_client, # Specify the user client here
  )

Initialiser l'agent dans la fonction de prédiction

Puisque l'identité de l'utilisateur n'est connue qu'au moment de la query, vous devez accéder aux ressources OBO à l'intérieur de predict ou predict_stream, et non dans la méthode __init__ de l'agent. Cela garantit que les ressources sont isolées entre les appels.

Python

from mlflow.pyfunc import ResponsesAgent

class OBOResponsesAgent(ResponsesAgent):
  def initialize_agent():
    user_client = WorkspaceClient(
      credentials_strategy=ModelServingUserCredentials()
    )
    system_authorized_client = WorkspaceClient()
    ### Use the clients above to access resources with either system or user authentication

  def predict(
    self, request
  ) -> ResponsesAgentResponse:
    agent = initialize_agent() # Initialize the Agent in Predict

    agent.predict(request)
    ...

Déclarez les périmètres d'API REST lors de la journalisation de l'agent.

Lorsque vous consignez votre agent OBO pour le déploiement, vous devez lister les champs d'application de l'API REST Databricks que votre agent appelle au nom de l’utilisateur. Cela garantit que l'agent suit le principe du moindre privilège : les jetons sont limités uniquement aux APIs dont votre agent a besoin, ce qui réduit le risque d'actions non autorisées ou d'utilisation abusive des jetons.

Sur les endpoints Model Serving, vous ne pouvez utiliser que les portées qui correspondent aux ressources prises en charge par OBO énumérées ci-dessus.

Pour activer l'authentification au nom de l'utilisateur, transmettez un AuthPolicy MLflow à log_model():

Python

import mlflow
from mlflow.models.auth_policy import AuthPolicy, SystemAuthPolicy, UserAuthPolicy
from mlflow.models.resources import DatabricksServingEndpoint

# System policy: resources accessed with system credentials
system_policy = SystemAuthPolicy(
    resources=[DatabricksServingEndpoint(endpoint_name="my_endpoint")]
)

# User policy: API scopes for OBO access
user_policy = UserAuthPolicy(api_scopes=[
    "model-serving",
    "ai-search"
])

# Log the agent with both policies
with mlflow.start_run():
    mlflow.pyfunc.log_model(
        name="agent",
        python_model="agent.py",
        auth_policy=AuthPolicy(
            system_auth_policy=system_policy,
            user_auth_policy=user_policy
        )
    )

Authentification OBO pour les clients OpenAI

Pour les agents qui utilisent le client OpenAI, utilisez le SDK Databricks pour vous authentifier automatiquement lors du déploiement. Le SDK Databricks dispose d'un wrapper pour construire le client OpenAI avec l'authentification configurée automatiquement, get_open_ai_client():

Python

% pip install databricks-sdk[openai]

Python

from databricks.sdk import WorkspaceClient
def openai_client(self):
  w = WorkspaceClient()
  return w.serving_endpoints.get_open_ai_client()

Spécifiez ensuite l'Endpoint de Model Serving dans resources pour une authentification automatique lors du déploiement.

Considérations de sécurité OBO

Prenez en compte les considérations de sécurité suivantes avant d’activer l’authentification utilisateur « au nom de » avec des agents.

**Accès étendu aux ressources** : Les agents peuvent accéder à des Ressources sensibles au nom des utilisateurs. Bien que les périmètres limitent les APIs, les Endpoint pourraient permettre plus d'actions que votre agent n'en demande explicitement. Par exemple, le périmètre d'API model-serving accorde à un agent la permission d'exécuter un endpoint de déploiement au nom de l'utilisateur. Cependant, l'endpoint de déploiement peut accéder à des périmètres d'API supplémentaires que l'agent d'origine n'est pas autorisé à utiliser.

Exemples de notebooks OBO

Le notebook suivant vous montre comment créer un agent avec AI Search en utilisant l'autorisation utilisateur « au nom de ».

Autorisation utilisateur « Au nom de » avec Recherche IA

Ouvrir le notebook dans un nouvel ongletOuvrir dans Databricks

Le notebook suivant vous montre comment créer un agent qui prend en charge l'exécution SQL sur un SQL Warehouse en utilisant l'autorisation au nom de l'utilisateur. Cela permet à l'agent d'invoquer en toute sécurité les fonctions Unity Catalog en utilisant les informations d'identification de l'utilisateur.

remarque

Il s'agit actuellement de la manière recommandée d'exécuter les fonctions UC avec OBO, car l'exécution Serverless Spark avec OBO n'est pas encore prise en charge.

Autorisation au nom de l'utilisateur avec exécution SQL

Ouvrir le notebook dans un nouvel ongletOuvrir dans Databricks

Authentification manuelle

L'authentification manuelle permet de spécifier explicitement les identifiants lors du déploiement de l'agent. Cette méthode offre la plus grande flexibilité, mais elle nécessite plus de configuration et une gestion continue des identifiants. Utilisez cette méthode lorsque :

• La ressource dépendante ne prend pas en charge la transmission automatique des informations d'authentification.
• L'agent doit utiliser des identifiants autres que ceux du déployeur de l'agent.
• L'agent accède à des ressources ou APIs externes en dehors de Databricks.
• L'agent déployé accède au registre de prompts

important

La substitution des variables d'environnement de sécurité désactive la transmission automatique pour les autres ressources dont votre agent dépend.

Authentification OAuth (recommandée)

OAuth est l’approche recommandée pour l’authentification manuelle, car il offre une authentification sécurisée basée sur des jetons pour les Service Principal avec des capacités de refresh automatique des jetons :

1. Créer un Service Principal et générer des identifiants OAuth.

2. Accordez au Service Principal des autorisations pour toute ressource Databricks à laquelle l’agent a accès privilèges d’accès aux ressources Databricks. Pour accéder au registre des invites, accordez les autorisations CREATE FUNCTION, EXECUTE et MANAGE sur le schéma Unity Catalog pour le stockage des invites.

3. Créer des secrets Databricks pour les identifiants OAuth.

4. Configurez les informations d'identification OAuth dans le code de l'agent :

   Python

   import os
   
   # Configure OAuth authentication for Prompt Registry access
   # Replace with actual secret scope and key names
   secret_scope_name = "your-secret-scope"
   client_id_key = "oauth-client-id"
   client_secret_key = "oauth-client-secret"
   
   os.environ["DATABRICKS_HOST"] = "https://<your-workspace-url>"
   os.environ["DATABRICKS_CLIENT_ID"] = dbutils.secrets.get(scope=secret_scope_name, key=client_id_key)
   os.environ["DATABRICKS_CLIENT_SECRET"] = dbutils.secrets.get(scope=secret_scope_name, key=client_secret_key)

5. Utilisez les secrets pour vous connecter à l'Workspace :

   Python

   w = WorkspaceClient(
     host=os.environ["DATABRICKS_HOST"],
     client_id=os.environ["DATABRICKS_CLIENT_ID"],
     client_secret = os.environ["DATABRICKS_CLIENT_SECRET"]
   )

6. Lors du déploiement avec agents.deploy(), incluez les informations d'identification OAuth en tant que variables d'environnement :

   Python

   agents.deploy(
       UC_MODEL_NAME,
       uc_registered_model_info.version,
       environment_vars={
        "DATABRICKS_HOST": "https://<your-workspace-url>",
        "DATABRICKS_CLIENT_ID": f"{secrets/{secret_scope_name}/{client_id_key}}",
           "DATABRICKS_CLIENT_SECRET": f"{secrets/{secret_scope_name}/{client_secret_key}}"
       },
   )

Authentification PAT

L'authentification par jeton d'accès personnel (PAT) offre une configuration plus simple pour les environnements de développement et de test, bien qu'elle nécessite une gestion manuelle accrue des identifiants :

1. Obtenez un PAT en utilisant un Service Principal ou un compte personnel :

   Service Principal (recommandé pour la sécurité) :

   1. Créer un Service Principal.
   2. Accordez au Service Principal les autorisations à toute ressource Databricks à laquelle l'agent a accès privilèges pour accéder aux ressources Databricks. Pour accéder au registre d'invites, accordez les autorisations CREATE FUNCTION, EXECUTE et MANAGE sur le schéma Unity Catalog utilisé pour stocker les invites.
   3. Créez un PAT pour le Service Principal.

   Compte personnel :

   1. Créer un PAT pour un compte personnel.

2. Stockez le PAT en toute sécurité en créant un secret Databricks pour le PAT.

3. Configurer l'authentification PAT dans le code de l'agent :

   Python

   import os
   
   # Configure PAT authentication for Prompt Registry access
   # Replace with your actual secret scope and key names
   secret_scope_name = "your-secret-scope"
   secret_key_name = "your-pat-key"
   
   os.environ["DATABRICKS_HOST"] = "https://<your-workspace-url>"
   os.environ["DATABRICKS_TOKEN"] = dbutils.secrets.get(scope=secret_scope_name, key=secret_key_name)
   
   # Validate configuration
   assert os.environ["DATABRICKS_HOST"], "DATABRICKS_HOST must be set"
   assert os.environ["DATABRICKS_TOKEN"], "DATABRICKS_TOKEN must be set"

4. Lorsque vous déployez l'agent à l'aide de agents.deploy(), incluez le PAT en tant que variable d'environnement :

   Python

   agents.deploy(
       UC_MODEL_NAME,
       uc_registered_model_info.version,
       environment_vars={
        "DATABRICKS_HOST": "https://<your-workspace-url>",
        "DATABRICKS_TOKEN": f"{secrets/{secret_scope_name}/{secret_key_name}}"
       },
   )